SHORT PAPER

Inverse kinematics computations with modified CORDIC iterations

C. Krieger B.J. Hosticka

Indexing terms: Inverse kinematics, Computations, CORDIC iterations

Abstract: The paper presents hardware solutions for the computation of inverse kinematics. They are based on an existing pipeline arithmetic processor which employs the CORDIC algorithm. It is shown that a slight modification of the standard CORDIC algorithm enables fast and efficient computation of the joint angles for the inverse kinematics. Due to this modification, the hardware amount and the computation time for the inverse kinematics computations are considerably reduced. The method yields an extended convergence range and a reduced number of iterations in comparison to the original CORDIC design. Another advantage of this method is that it yields an enhanced CORDIC functionality. Finally, a novel architecture for a new kinematic processor based on the modified CORDIC method is presented.

1 Introduction

In numerous engineering applications frequent compu- tations of trigonometric equations are necessary. A typ- ical example is represented by the inverse kinematics calculations. Kinematics of multibody systems (e.g. robot arms) deals with the calculations of the position, orientation and equivalent joint variables. These calcu- lations are carried out with respect to a fixed reference coordinate system regardless of forces and moments that are responsible for the motion. The derived expres- sions are time dependent. For robot systems, the kine- matic solution of the end effector is of special interest, but the derived equations apply to the common case of multibody systems without restrictions.

The kinematics of multibody systems consists of direct and the inverse kinematics solutions. The goal of direct kinematic solution is to find the position and ori- entation of the end effector of a manipulator with respect to a reference co-ordinate system. Inverse kine- matics, on the other hand, has to determine the joint angle vector, given the position and orientation of the OIEE, 1996 IEE Proceedings online no. 19960102 Paper first received 7th June 1995 and in revised form 11th October 1995 The authors are with the Fraunhofer Institute of Microelectronic Circuits & Systems, Finkenstrasse 61, D-47057 Duisburg, Germany

end effector. Because the trajectories to be traced are usually given in Cartesian co-ordinates, the computa- tions of the inverse kinematics are highly complex and require high speed implementation to generate smooth and rapid movements.

Currently there exist three basic methods for obtain- ing the solution of the inverse kinematics. These are the iterative approach [I], the algebraic approach by Paul ([2,3]), and the geometric one by Lee [4]. Additionally, a fourth approach was proposed by Hiller and Kec- skemethy ([5-7]), which combines the advantages of the geometric and algebraic approaches.

2

Kinematic solutions are based on homogeneous trans- formations [9]. These transformations contain mainly trigonometric functions which have to be computed separately for each joint angle. Since the homogeneous transformations can be decomposed into rotational and translational parts, hardware based on rotational arith- metics, such as CORDIC based processors, is particu- larly suitable for calculations of the kinematics equations. The CORDIC algorithm was originally developed by Volder [IO] for 2-D rotation and polar co-ordinate transformation, and was later substantially improved by Walther [l 11. It allows basically the com- putation of transcendental functions using shift and add operations only, and can be thus realised very effi- ciently in monolithic hardware. In the past many improvements of the originally CORDIC algorithm have been proposed by numerous researchers, aiming especially at the improvement of the convergence range and reduction of the number of iterations ([12-151). Nevertheless, the underlying idea in all CORDIC ver- sions has remained the same and has retained the sali- ent features of the original algorithm. To start with, we consider the CORDIC iterations based on the algo- rithm as given by Walther, where a, = (m)-1’2 ar~tan(dm2-~(~.~)) is the microrotation angle and S(m, i) the shift sequence:

Inverse kinematics using CORDIC processors

2,+1 = 5, - ma,2-S(m72)~L yz+l = y, + 0 2 2 - S ( m 4 &

(la) (1b ) ( I C ) &+I = z, - €O,a!,

After n iterations, the results of x, and yn have to be scaled by the scaling factor & E l ki to obtain the correct result. This adjustment accounts for the fact that the

81 IEE Proc.-Comput. Digit. Tech., Vol. 143, No. 1, January 1996

execution of eyn. l a and b causes improper vector con- striction or extension. There exist two fundamental modes, depending on which variable is forced to zero during the iteration process. The first mode is called the rotation mode and corresponds to z being forced to zero, while the second mode, called vectoring mode, forces y to zero. To ensure convergence, one has to be specify the sign control cjz for these modes in the fol- lowing way:

in rotation mode : mt = +sgn(c)sgn(z,)

0% = -sgn(y,)sgn(z,) (2b) The constant factor E determines the signs of the itera- tion results. Of special interest is the constant factor m E {-I, 0, l}. It specifies the type of rotation, as the iterations defined by eqns. 1 and 2 can be interpreted as rotations of a vector [xo, yo] on either a circle (m = 1), along a line (m = 0), or along a hyperbola (m = -1) into a new position given by [x,, y,] after n iterations. Another interpretation is simply that of rotational arithmetic which can compute various functions as sin(x), cos(x), exp(x), ln(x), ... .

in vectoring mode :

functions realised by Walther’s algorithm. The main characteristics of this processor are described in Table 1. As an example for inverse kinematics compu- tations, a simple wheel suspension will be now consid- ered (Fig. 1). The derived inverse kinematic solution is described by eqn. 3a - c:

+ arctan ( 2 (Vz:;.,s))

cos(&) cos(P) + sin(&) sin(P) . cos(/3) sin(a) - cos(ol) sin(/?) b = arctan

where S is the input variable and V are system con- stants. We use this example because it represents a generic system with features typical for the general inverse kinematics due to the underlying equation structures. All inverse kinematics equations have trigo- nometric functions, square, and square root expressions in common. The expressions of the solution of each joint angle can be written in general as:

0, = (arctan (E)) k

(4)

wheel / Fi 9.1 Simple wheel suspension

Table 1: Technical data of IMSCOR24 181 ~~

process CMOS, two metal layers

design rules 1.6pm chip area (13.3 x 14.2)mm2

package PGA 280

pipe stages 44 clock 10MHz

data format: extern 24 bit mantissa,

8 bit exponent (IEEE 754 single precision) or 24 bit fixed point

intern 32 bit mantissa, 10 bit exponent

control word 6 bit

In [SI the pipelined CORDIC processor (called IMS- COR24) with IEEE 754 floating point single precision standard was developed, which is able to compute all

88

Because the CORDIC algorithm computes two differ- ent functions in parallel, it is important to map the equations in a way that uses most efficiently this inher- ent parallelism. Hence the derived expressions must be examined for parallel dependencies. Also, simple addi- tions or multiplications using a CORDIC processor should be avoided, because those operations can be carried out much more efficiently using simpler arith- metic. Such terms should be rearranged and conven- iently substituted at a first step, (e.g. for the wheel suspension) introducing the following terms:

A = 2(VzY - V1,)S (5a)

B = 2V2,S ( 5 b ) c = VtZ + (V& - (54 + s2 - v;y + v:Z R = JA2 + B2 (54

we obtain

A hardware solution with the IMSCOR24 processor for the computation of the first joint angle p can be found in Fig. 2 (CAU = CORDIC arithmetic unit, FIFO first in-first out buffer). In Fig. 2 the CAUl calculates the angle $ and the norm R of the vector ( A , B), CAU2 then calculates the hyperbolic norm d(R2 - C2), and the last processor CAU3 computes finally the angle p. Other angles can be computed a in similar manner and hence we need eight CORDIC processors with a depth of four processor stages for the solution of the joint angle a. This yields a latency time of 1 7 . 6 ~

IEE Pvoc -Comput Digit Tech Vol 143, No 1, January 1996

for calculation of a, while three processors for the computation of 6 require 1 3 . 2 ~ . Hence the whole com- putation time takes about 4 4 p including the computa- tion time of p with 1 3 . 2 ~ (some extra operations are necessary for the computation of the variables A , B, and C).

U

Fig.2 Hardware solution for computation of f i

3 Modified cordic methods

As seen in the previous Section the hardware solutions for the inverse kinematics using a standard CORDIC processor, such as IMSCOR24, require many proces- sors. The computation can then either proceed using several processors arranged in pipelined manner, as depicted in Fig. 2, or a reduced number of processors can be used if some processors are shared for different computations. Although in the latter case the time mul- tiplexed operation requires a certain overhead and more intermediate data storage, the hardware complex- ity reduction may be considerable, but at cost of speed. The pipeline approach is not only expensive, but it is also less flexible. On the other hand, it yields high com- putational speed because of the use of the inherent par- allelism in the kinematics equations. To decrease the number of CORDIC processors, we now present a novel approach that relies on new modified CORDIC iteration method. Also, it extends the convergence domain in a simple way and reduces the number of iterations to achieve a 32 bit fixpoint accuracy.

Y 4

1

A XN R x Fig.3 Modijied CORDIC iterations

To achieve this the CORDIC iteration procedure, which originally required either z or y being forced to zero, is now changed so that the iteration process is driven to a final value specified by the implicit inverse kinematics equation. To illustrate this, we write eqn. 5e into the form given by eqn. 4 to derive an implicit expression, namely 8 = arctan(al/b,) - arctan(a2/b2). For $ = arctan(al/bl) we obtain tan($ - 8) = a2/b2. This can be rewritten and normalised so that we obtain sin($ - e) = a2/r2 and cos($ - 8) = b2/r2. This yields

sin($)cos(e) - cos($)sin(8) = a2/r2 and cos($)cos(O) + sin($)sin(e) = b2/r2. Substitution of the $ arguments gives finally:

(6) a1 cos(8) - bl sin(8) = - a21-1

1-2

b27-1 bl cos(8) + a1 sin(@) = - 1-2

(7)

where $ = arctan(al/!l), rl = d(a12 + bI2), r2 = + b22). It can be readily seen that the general form of eqns. 6 and 7 corresponds to:

B cos(8) f A sin(@) = C ( 8 ) This type of equation appears very often in inverse kin- ematics so that its efficient solution is very important. Although eqn. 8 contains CORDIC functions, it requires for its solution three standard CORDIC proc- essors. The novel solution we are proposing is based on the fact that iterative solution of eqn. 8 for 8 can be interpreted as an iterative vector rotation on a circle while y is forced to C. This can be easily realised as a modified CORDIC method: only the iteration goal must be changed when in vectoring mode. Fig. 3 shows the new type of rotation. As a result we obtain after n iterations an approximation 8, for the desired angle 8. Based on what we stated, the sign control of the stand- ard CORDIC algorithm for the vectoring mode has to be now modified to

a2 = -sgn(?/, - C)sgn(z,) (9) It is interesting to note that this method not only allows the computation using a single CORDIC proc- essor (instead of three) but also it enables computation of the arc functions like arccos(8) and arcsin(8). Again, only a single processor is needed, this time instead of two. As it can be seen in eqn. 8, to calculate the arc- cos(8) and arcsin(@), one has only to set A = xo = 0 or B = yo = 0, respectively. To obtain a unique solution constraints regarding the iteration range for C have to be evaluated. In the trigonometric vectoring mode the value of (Cl must not exceed the value of the norm R = d(x2 + y a ) . Note that, in standard CORDIC (given by eqns. 1 and 2), we have rotated a vector without modi- fying its norm during the iterations, but we scaled the vector co-ordinates at the end of the iteration process. Applying the same procedure to the modified CORDIC defined by eqn. 9 would yield a wrong angle due to the vector extension during the iterations. To avoid this, we will have to scale the vector co-ordinates x and y after each iteration to get a correct result (Fig. 3). This can be done by multiplying the actual co- ordinates x, and y , after each iteration by the corre- sponding scaling factor k,. Realising these multiplica- tions using hardware multiplier, however, would cancel the advantages of CORDIC, since its advantage is that it does not require any multipliers at all for implement- ing transcendental functions. Hence we try to realise the vector scaling without any hardware multipliers. For the proposed method, the scaling factors should be integers with the dual basis. To achieve this, we use for our algorithm an alternative description of the CORDIC algorithm that yields to a root-free scaling factor.

To illustrate our approach we first review automor- phic transformations [17], which are suitable to derive a general description of orthogonal matrices. Their use implies that matrices must be found which transform a given matrix A into itself, i.e. PrAP = A. It is to say

IEE Proc.-Comput. Digit. Tech., Vol. 143, No. I , January 1996 89

that the matrix P is a cogrediental automorphic transfor- mation of the matrix A (for complex matrices it is a hevmitian automorphic transformation). A very impor- tant case is represented by the cogrediental automor- phic transformations of the unity matrix. These transformations are defined by orthogonal matrices, namely RTAI = RQ = I. So all orthogonal matrices R with the constraint det(1 + R) f 0 can be written as R = (I + Y)-I(I - Y) = (I - Y)-'(I + U). Here Y describes all skew symmetric matrices with the constraint det(1 f U) # 0. For the two-dimensional case the skew symmetric matrices are:

Y = ( O . XI \-" U /

With this description, furthermore, it is possible to develop CORDIC algorithms for multidimensional cases [18]. After determing the inverse matrix in eqn. 10 for the two-dimensional case we obtain:

For h = tan(@/2) we obtain the well known rotation matrix for the two-dimensional case. It is interesting to note that eqn. 11 describes the CORDIC algorithm containing a root-free scaling factor.

Another advantage of the description given by eqn. 11 is that we now get a convergence domain for the rotation angle in the range of l@l 5 n. This is due to the fact that we have to start with the halved rotation angle in eqn. 11 to get a full rotation. This implies that eqn. 2 rotates a given vector by the doubled rotation angle. Nevertheless, the maximum definition range of @ is still the sum of the iteration angles given by Zzgil a, + an-l. These are defined by the shift sequences as in the standard CORDIC iterations with ai = (l/dm) a r~ tan (dm2-~(~ ,~~) . In [13,16] double shifts are used too, but in our contribution no prerotations [13] or argu- ment reduction techniques [11] are used to cover the range of [-n, n], as can be seen by using h = tan(@) instead of h = tan(@/2) in eqn. 11. Hence the root-free description yields a convergence domain twice the sum of the micro rotation angles.

Now, one has to rearrange eqn. 11 to get a descrip- tion of a unified CORDIC algorithm like the algorithm of Walther. For this purpose, we introduce the variable m to determine the three coordinate systems (hyper- bolic, trigonometric, and linear) known from the stand-

Xg Yg C Zg control

ard CORDIC algorithm:

With the above rotation matrix, we obtain the follow- ing unscaled iterations:

(13a) g-2 - ,2-2s("iIzi - ,,i2-S(m>i)+lyi

~i (13b) oi2-s(%i)+1zz + yi - ,'ps(m,i)

(13c) where S(m, i) is the shift sequence depending on the co- ordinate system m and the actual shift i and a(m, i) are the iteration angles. It is also possible to compute the hyperbolic functions using this CORDIC method, although these functions are not of great interest in inverse kinematics computations. In standard CORDIC algorithm the equations would have to be multiplied by the scaling factor k =&El 1/[1 + m2-2S(m,i)] after n iterations. In accordance with what we slaled about the CORDIC algorithm, we wish to avoid a pre- or postscaling by multiplications, since this would require a multiplier. There exist different methods [13,15] that make it possible to find shift sequences which allow use of simple scaling factors (typically a multiple to the basis two, which can be realised by binary shifting) to simplify the scaling process. Our method is to distribute the scaling factor over the entire iteration process (i.e. to carry out the scaling after each iteration), and approximate the scaling factor ki by an alternative scaling factor, namely,

Yi+l =

z;+1 = zi - Ea!(,, 2 ) q

(14) i. 2 - - 1 - ,v7i2-2s(">i)

with a desired accuracy of n n

Z = 1 ,=1 where ql E {-1, 0, l}. Accordingly the root-free CORDIC iterations are:

x,+1 = (2 , - m2-2S(m,z)z2 - moz2-s(m~z)+1yz) (16a)

x (1 - ,71z2-2s(">2) 1

x (1 - ,q22-25("q

= (az2-S(m,z)+1g-, + y, - m ~ - 2 S ( m , z ) y z ) (16b)

(16c) z,+1 = z, - €a(m, z ) 0 2

Now we have to find shift sequences with reduced numbers of iterations to reduce hardware requirements

q G 7 y11 XI+1 Y c l = 1+1

t X YZ

Fig.4

90

Modij7ed iteration stage for implicit CORDIC

IEE Pvoc.-Comput. Digit. Tech., Vol. 143, No. I , January 1996

and to increase computational speed. An exhaustive search leads to a set of parameters v i and an optimal shift sequence S(i) for the trigonometric mode shown in Tables 2 and 3 for standard rotation ( z + 0) and vec- toring (J + 0.5), respectively. As an example, the simu- lation results in Table 2 relate to a vector given by its initial co-ordinates xo = 1 and yo = 1 which is to be rotated by zo = 1.1780972451. This will be designated now as a vector x' = (1, 1, 1.1780972451) and yields the norm R = 42. As explained above, the algorithm rotates automatically by the doubled initial angle. That means here 2zo = 2.3561945 which is a rotation by 135". With the above iterations the convergence domain is in the range of Ocd = Zl?f ail + a22 = 1.6551658629, but because of the doubled rotation behaviour of the root-free CORDIC iterations, we have to start with the halved angle to get a full rotation. Hence, the useful convergence range doubles the size of Ocd and that allows rotation within the interval [-n, +XI. The scaling factor fulfils the condition given by eqn. L5, because k = II,y l/[l + 2-2s7 = 0.5779666273 and k = Hi?f 1 - 2-2s' = 0.5779666273 yields IR - kl = 9.921 x IO-" 5 2-22 = 2.3842 x With this approximation for the scaling factor we obtain an accuracy in the rotation mode of x22 - R 2 3 x = 2-32, which rep- resents a 32 bit accuracy, corresponding to nine deci- mal digits. This has been obtained from only 22 iterations in the trigonometric mode and a convergence domain in the range of

We now turn our attention to the modified CORDIC algorithm. The new feature of the modified CORDIC algorithm is that it can compute expressions of the type of eqn. 8 where the unknown variable is implicit. In Table 3 the s iplat ion results describe a rotation of an initial vector x = (1, 2, 0) with the iteration goal yn + c = 0.5, which corresponds to the equation 2cos(0) + sin(0) = 0.5. Due to its capability of calculating implicit trigonometric equations, we call this algorithm implicit. One can see that the accuracy in the vectoring mode is not as good as in the rotation mode. But this behav- iour is typical for any CORDIC algorithm. This is due to the dependence of yt+l , on the current value of x, which is not necessarily a monotonously decreasing sequence like the sequence of iteration angles a(m, i). In the above simulation (see Table 3) it can be seen that we now have to double the result in the z-path, which is equivalent to binary shift of z,, towards MSB to get the correct result. As can be seen, its hardware realisation requires additional adders in each iteration stage and, hence, the latency time of the chip also increases (Fig. 4). In contrast to the IMSCOR24 proc- essor, an equivalent processor with implementation of the CORDIC implicit iterations (Fig. 3) exhibits an increased latency time over all stages by a factor of 1.5, assuming that the adders play the dominant role in determing the latency. On the other hand, we need only a single implicit CORDlC processor instead of three pipelined standard CORDIC processors for inverse kinematics, so that the total latency time is effectively halved. Hardware savings are even more impressive. Hence the implicit CORDIC method is highly suitable for CORDIC-like computations in calculations of the inverse kinematics.

I 20cd = 3.3.

4 Conclusions

In design of mechanical systems much effort is devoted to kinematic calculations. These contain frequently a

IEE Proc -Comput Digit Tech, Vol 143, No I , Julnnuary 1996

Table 2: Results of the trigonometric rotation ( z + 0) simulations for root-free CORDIC

Parameters Rotation

i s, 11, x, Y, z,

1 1 1 -0.1875 1.3125 0.7 144496361

2 1 1 -1.08984375 0.59765625 0.2508020271

3 2 -1 -1.4030914307 0.0163421631 0.005823364

4 3 1 -1.3636090793 -0.3294565715 -0.1 185316306

5 3 1 -1.402406411 1 0.0163341845 0.005823364

6 4 0 -1.3989700341 -0.15900304223 -0.056595446

7 4 0 -1.4133841 102 -0.0164620445 -0.05823364

8 5 1 -1.4116528153 -0.071820333 -0.0254164695

9 5 1 -1.4133814144 0.0164620131 0.005823364

10 6 0 -1.4135507884 -0.0277101751 0.0098003646

11 6 0 -1.4140716262 0.0164700522 0.005823364

12 7 1 -1.4141563442 -0.0056254788 -0.0019889771

13 8 -1

14 9 1

15 10 -1

16 11 1

17 12 -1

18 13 1

19 14 0

20 15 1

21 16 -1

22 17 1

-1.4142002936 0.0054227862 0.001917253

-1.4142106868 -0.0001 014539954 -0.00003587

-1.414210885 0.0026606789 0.00094069272

-1.41421 28089 0.00127961 26 0.00045241 151

-1.4142134337 0.00058907899 0.00020827089

-1.4142135354 0.000243812 0.0000862006

-1.41 42 135599 0.00007 1 179 -0.000025 165

-1.44142135616 -0.000015138 -0.0000053522

-1.4142135617 0.0000280202 0.0000099066

-1.4142135621 0.000006441 0.0000022772

Table 3: Results of the trigonometric rotation (y + 0.5) simulations for implicit CORDIC

Parameters Implicit vectoring

i Si 11; 1 1 1

2 1 1

3 2 -1

4 3 1

5 3 1

6 4 0

7 4 0

8 5 1

9 5 1

10 6 0

11 6 0

12 7 1

13 8 -1

14 9 1

15 10 -1

16 11 1 17 12 -1

18 13 1

19 14 0

20 15 1

21 16 -1

22 17 1

x, Y, =, 2.0625 0.375 -0.463647609

0.87890625 1.7578125 0

1.80931 109131 1.2840270996 -0.2449786631

2.0692027174 0.7989546284 -0.3693336577

2.2016630495 0.2649644973 -0.4936886522

2.1 59942241 1 0.5391 373609 -0.431 2698422

2.2188971368 0.2670385755 -0.4936886522

2.1978918572 0.405060291 08 -0.4624488188

2.1 683094869 0.541 506251 -0.4312089854

2.1847021848 0.4736143758 -0.446832714

2.169368361 0.5417706906 -0.43 12089854

2.177568204 0.5078102467 -0.4390213264

2.1815355316 0.4907977354 -0.4429275566

2.1796017165 0.49931 55816 -0.440974434

2.1786264898 0.5035726203 -0.4399978718

2.1791 172209 0.50 144481 57 -0.4404861 531

2.1793620671 0.5003807936 -0.4407302937

2.1794841 654 0.4998487078 -0.440852364

2.1794231406 0.5001 147563 -0.440807913288

2.179453661 1 0.4999817339 -0.4408218464

2.1794384024 0.5000482455 -0.4408065876

2.1794460324 0.5000149898 -0.440814217

large number of different trigonometric functions, which can be readily computed using CORDIC proces- sors. Especially the calculation of the joint angles typi-

91

cally given by expressions such as Bcos(0) k Asin(@) = C is a common problem. When using standard CORDIC algorithms for their hardware computation, up to three CORDIC processors are necessary for a parallel hardware computation. In this contribution we have introduced a novel concept called implicit CORDIC algorithm which enables efficient computa- tion of such equations using only a single CORDIC processor. It is based on a root free description of the CORDIC algorithm and slightly modified iteration goal. Furthermore, the functionality of the CORDIC is increased due to the possibility of computing the arccos and arcsin functions, again using only a single proces- sor. This functonality extension is available for the hyperbolic arc functions too, but another shift sequence is to be used. Although the modified CORDIC requires an increased hardware amount for each iteration stage and also latency time per stage increases, it has the advantage of a large convergence range in the trigonometric mode of 2 .n without additional shifts. Further, it lends itself to operating with shift sequences that enable reaching a 32 bit accu- racy with reduced numbers of iterations.

5 A c k n ~ w ~ e ~ g m e n t ~

Many thanks go to Prof. M.Hiller, Dr. A.Keck- sltemethy, and T.Krupp for useful discussions.

References

UICKER, J., DENAVIT, J., and HARTENBERG, R.: ‘An iter- ative method for the displacement analysis of spatial mecha- nisms’, Trans. ASME, J. Appl. Mech., 1964, pp. 309-314 PAUL, R.P., SHIMANO, B., and MAYER, G.E.: ‘Kinematic control equations for simple manipulators’, IEEE Trans., 1981, SMC-11, (6)

PAUL, R.P., and ZONG, H.: ‘Computationally efficient kine- matics for manipulators with spherical wrists based on the homo- geneous transformation representation’, Int. J. Robotics Res., 1986, 5, (2) LEE, H.Y., and LIANG, C.G.: ‘A new vector theory for the analysis of sDatial mechanisms’. Mech. Mach. Theorv, 1988, 23, (3). pp. 209-217 HILLER. M.. and KECSKEMETHY. A.: ‘Eauations of motion of complex multibody systems using kinemitical differentials’, Trans. Can. Soc. Mech. Eng., 1989, 13, (4), pp. 113-121 KECSKEMETHY, A.: ‘Object-oriented modelling of mechanical systems’, Kinematics and dynamics of multi-body mechanical sys- tems, CISM-Course, Italy, 1994 KECSKEMETHY, A., and HILLER, M.: ‘Automatic closed- form kinematics-solution for recursive single-loop chains’, 22nd biennial mechanisms conference, Scottsdale, Arizona, 1992 TIMMERMANN, D., RIX, B., HAHN, H., and HOSTICKA, B.J.: ‘A CMOS floating-point vector arithmetic unit’, IEEE J., 1995, SSC-29, (5) LEE, C.S.G.: ‘Robot arm kinematics, dynamics, and control’, ZEEE Contout., 1982, 15, (12). pp. 62-80 . , _ _

10 VOLDER; J.E.: ‘The trigonometric computing techniques’, Trans. Electr. Comput., 1959, EC-8, (3), pp. 330-334

11 WALTHER, J.S.: ‘A unified algorithm for elementary functions’, Spring joint computer conference (SJCC), 1971, pp. 379-385

12 HAVILAND, G., and TUSZYNSKI, A.: ‘A CORDIC arithmetic processor chip’, Trans. Comput., 1980, C-29, (2), pp. 68-79

13 ALFONS , DE LANGE, A.J., and DEPRETTERE, E.F.: ‘Design and implementation of a floating-point quasisystolic gen- eral purpose CORDIC rotator for a high-rate parallel data and signal processing’, IEEE Proceedings of the 10th symposium on computer arithmetic, France, 1991

14 TIMMERMANN, D., HAHN, H., and HOSTICKA, B.: ‘Modi- fied CORDIC-algorithm with reduced iterations’, Electr. Lett., 1989, 25, (15)

15 DESPAIN, A.M.: ‘Fourier transform computers using CORDIC iterations’, IEEE Trans., 1974, C-23, (lo), pp. 993-1001

16 AHMED, H.M.: ‘Signal processing algorithms and architectures’. PhD thesis, Department of Electrical Engineering, Stanford Uni- versity, 1982

17 GROEBNER, W.: ‘Matrizenrechung’ (BI-Verlag, Mannheim (Germany), 1966)

18 DELOSME, J.M.: ‘CORDIC algorithms: theory and extensions’, in ‘Advanced algorithms and architectures for signal processing’, IVProc. SPIE, 1989, 1152, pp. 131-145

92 IEE Proc.-Comput. Digit. Tech., Vol. 143, No. 1, January 1556