Computer-Aided Constrained Robot Design Using Mechanism. Synthesis Theory

Transcription

1 UNIVERSITY OF CALIFORNIA, IRVINE Computer-Aided Constrained Robot Design Using Mechanism Synthesis Theory DISSERTATION submitted in partial satisfaction of the requirements for the degree of DOCTOR OF PHILOSOPHY in Mechanical and Aerospace Engineering by Hai-Jun Su Dissertation Committee: Professor J. Michael McCarthy, Chair Professor James E. Bobrow Professor David Reinkensmeyer 2004

2 c 2004 Hai-Jun Su

3 The dissertation of Hai-Jun Su is approved and is acceptable in quality and form for publication on microfilm: Committee Chair University of California, Irvine 2004 ii

4 Dedication To my dear wife iii

5 Table of Contents List of Figures xi List of Tables xiv Nomenclature xvi Acknowledgements xvii Curriculum Vitae xviii Abstract of the Dissertation xxi 1 Introduction Overview Mechanism Synthesis Theory The CS and RPS Chains The TS Chain Other Synthesis Results Contributions iv

6 1.3 Roots of Polynomial Systems Polynomial Homotopy Method Resultant Elimination Methods Contributions Computer-Aided Synthesis of Linkages Planar Linkages Spatial Linkages Robots Contributions Summary of Contributions Organization Constrained Robotic Systems Overview Kinematics Background Homogeneous Transformation Dual Quaternion Kinematic Joints and Links Kinematic Equation of Serial Robots Kinematic Equation of Parallel Robots Enumeration of Constrained Robots Constrained Serial Robots v

7 2.3.2 Constrained Parallel Robots Simulating Constrained Robotic Systems Differential Kinematics of Serial Chains Dual Quaternion Metric Differential Kinematics of Parallel Chains Inverse Kinematics Trajectory Planning Numerical Examples Summary Roots of Polynomial Systems Overview A Polynomial System Homogenization Root Counting Polynomial Homotopy Method Homotopy Function Path Tracking Linear Product Based Start Systems POLSYS GLP Homotopy Solver Resultant Elimination Methods Resultant Elimination Steps for Solving Polynomial Systems. 61 vi

8 3.4.2 Resultant of a Polynomial System Computing Resultant Using Generalized Eigenvalue Techniques Resultant Solution to a Class of Quasi-Bilinear Polynomial Systems A Quasi-Bilinear Polynomial System Resultant Solution for the Case n = 5, l = 3, m = Generalization Summary Serial Chain Constraint Equations Overview Burmester Problem Spatial Burmester Problem The Plane The Sphere The Elliptic Cylinder The Circular Cylinder The Circular Hyperboloid The Circular Torus The General Torus Summary Design of Serial and Parallel Robots Overview vii

9 5.2 Design of CS Robot CSn Design Problems Homotopy Solution to CS7 and CS8 Design Resultant Solution to CS3, CS4,CS5 and CS6 Design A Numerical Example for CS6 Design Design of RPS Robot RPSn Design Problems Homotopy Solution to RPS9 and RPS10 Design Resultant Solution to RPS6, RPS7 and RPS8 Design A Numerical Example for RPS8 Design Design of 3RRS Parallel Robot A Symmetric 3RRS Parallel Robot Design Equations Design Problems A Homotopy Solution and Numerical Example Summary Synthetica Overview Software Architecture Functionalities and Features Synthetica Packages viii

10 6.4.1 Package mechanism Package GUIModules Package glprimitives Package kinemath Implementing Routines for Synthetica Implementation Steps Example Integration Example of the Use of Synthetica Summary Conclusions and Future Research 157 A POLSYS GLP User s Guide 169 A.1 Compilation and Usage A.2 README File A.3 Mathematica Notebook for Preparing INPUT.DAT A.4 Sample INPUT.DAT and OUTPUT.DAT B Synthetica User s Guide 214 B.1 System Requirements and Usage B.2 Graphical User Interface Components C Partial Synthetica Source Code 222 C.1 Serial RR 3Pos 0Con.java ix

11 C.2 Joint.java C.3 Mechanism.java C.4 SerialMechanism.java x

12 List of Figures 1.1 A three degree-of-freedom 3CS parallel platform can be designed to reach up to eight arbitrary positions A link connects two joints A serial robot is a sequence of links connected by joints A parallel robot formed by m serial chains A TPR chain imposes two constraints, so a 2TPR spatial linkage has two degrees-of-freedom A RPS chain imposes one constraint, so a 3RPS spatial linkage has three degrees-of-freedom Flowchart of the trajectory planning algorithm Example of the trajectory of a 2TPR linkage that approximates a specified trajectory Example of the trajectory of a 3RPS linkage that approximates a specified movement Homotopy path tracking xi

13 3.2 Flowchart of POLSYS GLP homotopy solver Parallel path tracking with MPI Burmester problem: five position synthesis of planar RR chain A plane as traced by a point at the wrist center of a PPS serial chain A sphere traced by a point at the wrist center of a TS serial chain The elliptic cylinder reachable by a PRS serial chain The circular cylinder reachable by a CS serial chain The circular hyperboloid traced by the wrist center of an RPS serial chain The circular torus traced by the wrist center of a right RRS serial chain The general torus reachable by the wrist center of an RRS serial chain The 4th CS chain of Table 5.5 is shown reaching the six design positions The 8th RPS chain of Table 5.10 is shown reaching the eight task positions A symmetric 3RRS parallel platform A symmetric 3RRS platform reaching the two task postions The architecture of Synthetica The desktop of Synthetica Synthetica package organization xii

14 6.4 Mechanism package organization DesignMatrix panel allows users to select a synthesis routine TaskSpecifier panel for specifying a design task MechanismViewer panel displays data structure of mechanisms B.1 The toolbar for manipulating files, viewer and objects B.2 The object tree structure B.3 The option dialog B.4 The Matrix4d clipboard B.5 The animation toolbar B.6 Data viewer panel for displaying animation frames B.7 The workpiece panel B.8 Longitude(θ), latitude(φ), and roll(ψ) coordinates defining an orientation219 B.9 Mechanism teach panel for driving joint parameters B.10 Matrix4dSpecifier dialog for specifying 4 4 homogeneous matrices. 221 B.11 The trajectory panel xiii

15 List of Tables 2.1 The six basic joints Serial chains with four, three, and two degrees-of-constraint Enumeration of single degree-of-constraint serial chains Enumeration of constrained parallel robots The Denavit-Hartenberg parameters for the TPR chain The base and end-effector frames of a 2TPR system The Denavit-Hartenberg parameters used for the RPS chain The base and end-effector frames of a 3RPS system Resultant formulations for a class of quasi-bilinear polynomial systems. Note N r gives the root count which has been predicted by the GLP Bezout number B GLP (n, l) = l ( n ) i=0 i The basic serial chains and their associated reachable surfaces Summary of the number of task positions, total degree, GLP bound, and number of solutions that define each reachable surface The GLP bound on CSn design problems. The bound is exact for n xiv

16 5.2 Homotopy solution to the CS7 and CS8 design. Run time is obtained by executing POLSYS GLP on a Pentium 4 1.5GHz system Resultant solution to the CS3-6 design problems A set of six task positions for the CS6 design problem that has 26 real solutions The 26 CS chains that reach six specified positions The GLP bound on RPSn design problems. The bound is exact for n Homotopy solution to RPS9 and RPS10 design problems. Run time is obtained by executing POLSYS GLP on a Pentium 4 1.5GHz system Resultant solution to the RPS6-8 design A set of eight task positions for RPS8 design The 19 RPS chains that reach eight task positions The number of task positions and free parameters for symmetric 3RRS, 4RRS and 5RRS platforms The Denavit-Hartenberg parameters of solution 4 in Table Joint parameters for task positions 1 and Real solutions 1-35 for 3RRS two position synthesis Real solutions for 3RRS two position synthesis xv

17 Nomenclature Roman symbols [M] M {v A matrix. The determinant of a matrix. A column vector (v x, v y, v z ) A row vector p p T, [R] T ˆQ Q A vector; also a three-dimensional point. The transpose of a vector or a matrix A dual quaternion. A quaternion. The cross-product of three-dimensional vectors. The dot product of vectors. [Z(θ, d)] A screw displacement about the Z axis, of rotation θ and translation d. [X(α, a)] A screw displacement about the X axis, of rotation α and translation a. xvi

18 Acknowledgements For the past five years, I had a wonderful experience at UCI. Many people have contributed to the development of this research. I would like to give the first thank to my family for their love, encouragement and patience throughout this long trip, especially to my father-in-law, my mentor, Prof. Qizheng Liao who led me to the door of this research. My parents and mother-in-law also deserve many thanks for their patience and support. I thank my dear wife for her continuous love, encouragement and friendship. I would also like to thank my advisor, Professor J. Michael McCarthy for his help, support and guidance. Without him, I would not have achieved this level of success. To Prof. Peter Dietmaier, Dr. Charles Wampler, Prof. Layne Watson and Prof. Tangan Gao I give thanks for their collaboration and guidance in this research. I am also thankful to Dr. Curtis Collins and Prof. Alba M. Perez for their suggestions and helps in this research. I am grateful to my committee, Prof. James Bobrow and Prof. David Reinkensmeyer for their interests in my research and for their valuable remarks. I want to thank my colleagues of robotics and automation laboratory, especially Juanita Alba, Eric Wang and Shawn Ahlers. I would also like to thank all my friends at UCI for providing us help in the past five years. xvii

19 Curriculum Vitae Hai-Jun Su Education 09/2004 Ph.D. in Mechanical and Aerospace Engineering, Department of Mechanical and Aerospace Engineering, University of California, Irvine, CA. Advisor: J.Michael McCarthy. 03/1998 M.S. in Mechanical Engineering, Department of Mechanical Engineering, Beijing University of Posts and Telecommunications (BUPT), Beijing, China. Advisor: Qi-Zheng Liao. 07/1995 B.S. in Mechanical Engineering, Department of Mechanical Engineering, Beijing University of Posts and Telecommunications (BUPT), Beijing, China. Experience 06/ /2004 Design Engineer, development, simulation and FEA of linkage architectures for a morphing aircraft wing structure, sponsored by NextGen Aerospace Inc., Project manager: David Cowen, CA. 09/ /2004 Research Assistant, development of mathematic and simulation tools for spatial mechanism design, Ph.D. advisor: Prof. J. Michael McCarthy, UCI. 01/ /2004 Teaching Assistant, E80, CEE80, MAE80, Dynamics, course professor: F. Jabbari. 09/ /2003 Lecturer, MAE246 Algebraic Geometry in Kinematics, Dept. of Mechanical and Aerospace Engineering, UCI. 04/ /2002 Reader, MAE145, Theory of Machines and Mechanisms, course professor: J. M. McCarthy Research Engineer, kinematics, simulation and singularity analysis of a 6R painting manipulator, sponsored by Beijing Institute of Automation, China Research Assistant, kinematic analysis of parallel platform mechanisms, supervisors: Qi-Zheng Liao and Chong-Gao Liang, Department of Mechatronics Engineering, BUPT, China. xviii

20 Awards 04/2004 Dissertation Fellowship, Department of Mechanical and Aerospace Engineering, University of California, Irvine. 09/2002 MDI Simulation Software Award, for paper An Extensible Java Applet for Spatial Linkage Synthesis, 27th Biennial Mechanisms and Robotics Conference ASME, Montreal, Canada Fellowship, Department of Mechanical and Aerospace Engineering, University of California Irvine. Publications 1. Su H.-J., McCarthy J.M., Sosonkina M. and Watson L.T., 2004, POLSYS GLP: A Parallel General Linear Product Homotopy Code for Solving Polynomial Systems of Equations, submitted to ACM Transactions on Mathematical Software, August. 2. Wolbrecht, E., Su, H.-J., Perez, A. and McCarthy, J.M., 2004, Geometric Design Of Symmetric 3-RRS Constrained Parallel Platforms,, ASME International Mechanical Engineering Congress and Exposition, Anaheim, CA, November Perez A., Su, H.-J., and McCarthy, J.M., 2004, SYNTHETICA 2.0: Software for the Synthesis of Constrained Serial Chains, ASME Design Engineering Technical Conferences, Salt Lake City, Sept. 28-Oct Su, H.-J. and McCarthy, J.M., 2004, Inverse Static Analysis for A Planar Compliant Platform Mechanism, ASME Design Engineering Technical Conferences, Salt Lake City, Sept. 28-Oct Su, H.-J., Wampler, C.W. and McCarthy J.M., 2004, Geometric Design of Cylindric PRS Serial Chains, ASME Journal of Mechanical Design, 126(1): Su H.-J., Dietmaier, P. and McCarthy J.M., 2003, Trajectory Planning for Constrained Parallel Manipulators, ASME Journal of Mechanical Design, 125(4): Su, H.-J., Dietmaier, P. and McCarthy J.M., 2004, Trajectory Planning for Spatial Platform Linkages, Proceedings of the 11th World Congress in Mechanism and Machine Science, April, Tianjin, China. xix

21 8. Su H.-J., McCarthy J.M. and Watson L.T., 2004, Generalized Linear Product Polynomial Continuation and the Computation of Reachable Surfaces, ASME Journal of Information and Computer Sciences in Engineering, in press. 9. Su, H.-J., Wampler, C.W. and McCarthy J.M., 2003, Geometric Design of Cylindric PRS Serial Chains, ASME Design Engineering Technical Conferences, Sept.02-06, Chicago, IL. 10. Su, H.-J. and McCarthy J.M., 2003, Kinematic Synthesis of RPS Serial Chains, ASME Design Engineering Technical Conferences, Sept.02-06, Chicago, IL. 11. Su H.-J. and McCarthy J.M., 2003, Kinematic Synthesis of RPS Serial Chains for a Given Set of Task Positions, submitted to Mechanism and Machine Theory. 12. McCarthy J.M. and Su H.-J., 2004, Computation of Reachable Surfaces for a Specified Set of Spatial Displacements, Handbook of Computational Geometry for Pattern Recognition, Computer Vision, Neurocomputing and Robotics, Springer Verlag. 13. Su, H.-J., Collins, C.L., and McCarthy, J.M., 2002, An Extensible Java Applet for Spatial Linkage Synthesis, ASME Design Engineering Technical Conferences, Sept.29-Oct.2, Montreal, Quebec, Canada. 14. Su, H.-J., Collins, C.L., and McCarthy, J.M., 2002, Classification of RRSS Linkages, Mechanism and Machine Theory, 37: Collins, C.L., McCarthy, J. M., Perez, A., and Su, H.-J., 2002, The Structure of an Extensible Java Applet for Spatial Linkage Synthesis, ASME Journal of Computing and Information Science in Engineering, 2: Gascons, N., Su, H.-J. and McCarthy, J.M., 2002, Performance Evaluation of the Grasp of Two Cooperating Robots Using a Type Map, Advances in Robot Kinematics, Kluwer Academic Publishing, Spain, pp Su, H.-J., and McCarthy, J.M., 2001, Classification of Design for RRSS Linkages, ASME Design Engineering Technical Conferences, Sept.9-12, Pittsburgh, PA. 18. Su, H.-J., Liao, Q., and Liang, C., 1999, Direct Positional Analysis of a kind of 5-5 Platform In-Parallel Robotic Mechanism, Mechanism and Machine Theory, 34: Su, H.-J., Liao, Q., Liang, C., Wu, T., 1999, Algebraic Elimination Algorithm for Solving the Inverse Kinematics of General 6R Manipulators, Journal of Robots (in Chinese), 21: xx

22 Abstract of the Dissertation Computer-Aided Constrained Robot Design Using Mechanism Synthesis Theory By Hai-Jun Su Doctor of Philosophy in Mechanical and Aerospace Engineering University of California, Irvine, 2004 Professor J. Michael McCarthy, Chair This dissertation formulates and solves the algebraic design equations for five degree-of-freedom articulated chains that generalize the planar RR chains used in mechanism synthesis theory. Planar RR chains are characterized by the requirement that the moving pivot lies on a circle around the fixed pivot, and they introduce one degree of constraint to the end-effector movement. Here our focus is on spatial chains that are characterized by the requirement that the center of a spherical wrist lies on a surface, which constrains the end-effector to one degree-of-constraint, or five degrees-of-freedom. These chains, and parallel systems constructed from them, are called constrained robotic systems. The synthesis problem begins with a task defined as a set of goal positions for the end-effector of the chain. These positions can be viewed as an approximation of xxi

23 the workspace desired for the system. Because the spherical wrist allows all orientation of the end-effector, the focus is on the set of points traced by the wrist center, called the reachable surface. Seven constrained serial chains and their associated reachable surfaces are identified. They are denoted: PPS (plane), TS (sphere), RPS (hyperboloid), CS (cylinder), PRS (elliptic cylinder), right RRS (circular torus), and RRS (torus). Design equations for each of these chains can be obtained from the equations of the associated surface. The result is a set of polynomial equations that range from total degree 32 for the PPS chain (plane) to over 4 million for the general RRS chain (torus). For simple cases, we use sparse matrix resultant method to obtain analytical solutions. For more complicated cases, a new polynomial homotopy solver POLSYS GLP is developed and adapted to parallel computer systems. For example the case RRS12 has 42,786 roots and required 45 minutes on 1024 processors of the San Diego Supercomputer Center s Blue Horizon system. Finally, the analysis and synthesis routines are packaged into a Java and OpenGL based computer-aided design environment called Synthetica. The Java-based architecture has been designed to allow user-collaborators to integrate new synthesis routines into the system using dynamic binding. A general purpose kinematics solver for constrained robotic systems has been developed to simulate their movement. The result is a versatile high level synthesis and simulation system for articulated serial and parallel chains. xxii

24 Chapter 1 Introduction 1.1 Overview In this dissertation, we focus on the design of spatial serial chains that have less than six degrees-of-freedom, and the design of parallel platforms with these chains as supporting legs. Joshi and Tsai (2002) [25] call these systems limited DOF manipulators, however, we use the term constrained robotic systems because they introduce a constraint on the movement of the end-effector. Examples of constrained robots are the 3RPS system by Huang et al. (2002) [22], the 3PSP by Gregorio and Parenti-Castelli (2001) [18], and the double tripod by Hertz and Hughes (1998) [21]. Figure 1.1 shows that a 3CS parallel robot can be designed to reach up to eight specified task positions. The mathematical description of the constraint that the serial chain imposes on the end-effector can be evaluated on a set of task positions to provide design equations. The solution of these design equations yield the dimensions of the serial chain that 1

25 Task Pos8 Task Pos1 end-effector sphereical(s) joint cylindric(c) joint Figure 1.1: A three degree-of-freedom 3CS parallel platform can be designed to reach up to eight arbitrary positions. reaches the goal positions. This strategy for serial and parallel robot design generalizes the traditional result of mechanism synthesis theory. In this chapter, we provide a survey of research in mechanism synthesis theory, solution of polynomial systems and computer-aided design of robotic systems that provides the background for this dissertation. Finally, we summarize the contributions and organization of this thesis. 1.2 Mechanism Synthesis Theory Our formulation of the synthesis problem was introduced by Burmester (1886) [4], who sought in a planar moving body the points that trace circles. These points can then be used as the moving pivots of cranks that rotate around the pivot at the center of the circle. Burmester showed graphically that five arbitrary positions of a moving 2

26 body can define as many as four of these points, called Burmester points. A modern formulation of this problem yields five quadratic equations in five unknown parameters which are the coordinates of the fixed and moving pivots and the length of the crank, see Suh and Radcliffe (1978) [65] or McCarthy (2000) [41]. While, in general, five quadratic equations can have as many as 2 5 = 32 solutions, these are found to be bilinear and therefore have at most six roots. The form of these equations specialize even further to yield at most a total of four roots. We find that the design equations for the spatial chains that we study have similar features. The monomial structure of the polynomial system allow an estimate of the number roots which is less than the total degree. However, when these equations are solved it can happen that there are actually less roots due to even more specialized structure The CS and RPS Chains Burmester s ideas were generalized to spatial chains by Chen and Roth (1969) [6] who sought points in a moving body that take positions on a cylinder, sphere and hyperboloid. They formulated the design equations for the CS, TS and RPS chains that guide their wrist centers on these surfaces, respectively. Chen used an algebraic surface intersection technique to count the roots of a number of these cases. The general cases for the CS and RPS chains were complicated, therefore they chose the axes of the associated cylinder and hyperboloid. Nielsen and Roth (1995) [46] revisited the polynomial systems derived by Chen and 3

27 Roth (1969) and applied sparse matrix elimination techniques to obtain algebraic solutions that verified the original root counts. In the CS case (a cylinder with a specified axis), they solved five quadratic equations in five unknowns by introducing 175 equations in 140 monomials that were reduced to a generalized eigenvalue problem of degree 26. Thus, the system has a total of 26 roots rather than the 32 suggested by the total degree. For the RPS chain (a hyperboloid with a specified axis), they solved seven quadratic equations in seven unknowns, by introducing 336 equations in 288 monomials. The result is a generalized eigenvalue problem of degree 42. In this case, the 42 roots were again less than the 2 7 = 128 expected from the total degree The TS Chain The spatial Burmester problem has also been studied by Innocenti (1994) [23], who sought the point in the moving body that lie on a sphere. He formulated the design equations for seven spatial positions, and found an example in which all 20 roots are real, verifying the calculations of Chen and Roth, also see Liao and McCarthy (2001) [35]. Wampler (1990) solved the TS design equations to demonstrate a homotopy technique for solving polynomial systems Other Synthesis Results Tsai (1973) [68] derived the design equations for dyads (two links) and triads (three links) using screw theory. However he did not provide a solution to most cases. 4

28 Recent research in spatial mechanism synthesis has focussed on chains constructed from hinged or prismatic joints, denoted R and P, respectively. Perez and McCarthy (2000) [48] and Mavroidis et al. (2001) [39] presented two different approaches to formulating and solving the design equations for spatial RR chains. Mavroidis (2002) derived the synthesis equations for RRR [31, 32] and PRR [33] serial chains using 4 4 homogeneous matrices. The polynomial homotopy method, interval analysis method and polynomial elimination method are used to solve these equations. Perez (2003) [52, 50] systematically derived the synthesis equations of constrained robots using a dual quaternion formulation. Numerical iteration method was used to solve for a number of synthesis problems including CRR serial chain [51], 2TPR parallel chain [49] Contributions In what follows, we also examine TS, CS and RPS design problems and formulate their solution. In particular, we obtain for the first time the solutions for the general cases of the CS and RPS polynomial systems which have a total degree 16, 384 and 262, 144 respectively. The structure of these polynomials allows an estimate of the maximum number of roots to be refined to 2, 184 and 9, 216, while our computations show that the actual number of roots are 804 and 1024, respectively. We also examine the PPS, the PRS, right RRS and general RRS chains that guide their wrist centers on a plane, an elliptical cylinder, a right circular torus, and a general torus respectively. As an example, our design equations for the general torus 5

29 yields a polynomial system of degree 4,194,304, while its monomial structure yields a better bound of 448,702 roots. However, our solutions show that there are 42,786 roots to this design problem. Finally, we consider the design of symmetric platforms formed by these chains. 1.3 Roots of Polynomial Systems Many problems in kinematics and robotics lead naturally to systems of polynomial equations. Numerous algorithms have been developed for finding the solutions of a polynomial system over centuries. Many of them have been applied to kinematics and robotics problems. Examples are Newton-Raphson s iteration method [50], interval analysis [31], optimization based method [47] and genetic algorithm (GA) [34] etc. Raghavan and Roth (1995) [54] summarized various methods for solving polynomial systems and their applications to kinematics problems. However this dissertation focuses on methods that can obtain all solutions to a polynomial system, particularly the polynomial homotopy method and resultant elimination method Polynomial Homotopy Method Homotopy method, also called continuation method, for polynomial systems were first proposed by Garcia and Zangwill (1977) [15]. The idea is based on the fact that small changes on the coefficients of the polynomial systems will result small changes to the roots. Starting at roots of a start system, homotopy method traces the 6

30 solution along the so-called homotopy paths as the start system is continuously transformed into the target system. After many years of development, homotopy path trackers based on probabilityone homotopy methods are reliable and fast. Now work has shifted towards lowering the number of homotopy paths. In essence, all the methods try to construct a start system that better models the monomial structure of the target system. In this area, early work includes m-homogeneous theory by Morgan and Sommese (1987) [43]. Generalizations of m-homogeneous theory appeared in Verschelde and Haegemans (1993) [73] with the GBQ method, and in Verschelde and Cools (1993) [72] with set-structure analysis. The most recent definitive theoretical work is on the product-decomposition based start system and Bezout bound by Morgan, Sommese, and Wampler (1995) [44]. If all the factors are linear, this is the linear product based start system. Four cases of linear product based start system are 1-homogeneous, m-homogeneous, partitioned linear product (PLP) structure and generalized linear product (GLP) structure in the order of ascending generality. The most general start system is based on general monomial structure. Bernshtein (1975) [1] shows that the root count for any monomial structure can be obtained from the mixed volume of the associated Newton polytopes, a result sometimes known as the BKK bound. BKK bound is usually tighter the linear product decomposition bound. However mixed volume is combinatorial in nature, and can require extensive computer calculation. Gao and Li (2003) [16] provide an efficient algorithm for 7

31 computing mixed volume. Publicly available codes for solving polynomial systems of equations using globally convergent, probability-one homotopy methods do exist: HOMPACK [75], written in FORTRAN 77, and its successor HOMPACK90 [76], written in Fortran 90, both have polynomial system solvers. CONSOL in the book by Morgan (1987) [42] is also written in FORTRAN 77. However, neither HOMPACK90 nor CONSOL has a sophisticated start system that can lower the number of homotopy paths that must be tracked below the total degree. POLSYS PLP [77], written in FORTRAN 90, supports the more general partitioned linear product (PLP) structure. The package PHCPACK by Verschelde (1999) [71], written in Ada, allows a great variety of choices for the start system Resultant Elimination Methods While polynomial homotopy method provides a solution to median and large polynomial systems, it is computationally demanding. In the situation when computation time is essential, resultant elimination is preferable. The main advantages of resultant method lies in the fact that the resultant can always be expressed in terms of matrices and determinants. As a result, we are able to use algorithms from linear algebra and obtain tight bounds on the running time. Furthermore, resultant formulation can be pre-processed offline. For this reason, resultant methods provide the most efficient solution for small and median polynomial systems. The history of classical resultants dates back to the work of E.Bezout (1779) 8

32 [2] who constructed from two univariate polynomials a square matrix, called Bezoutian matrix. J. J. Sylvester (1853) [67] reformulated the work and preferred to multiplying the original polynomials with a list of monomials. His result is now known as Sylvester matrix. A generalization of the Bezoutian in multivariate case was the work of A. Dixon (1908) [11], known as Dixon s matrix. F.S Macaulay (1902) [36] generalized the Sylvester resultant to multivariate case, which is called Macaulay s resultant. These formulations are often called classical resultants. See I. Z. Emiris(1999) [12] for a comprehensive survey on resultant elimination theory. The last two decades have witnessed the rebirth of resultant method. In particular, the advent of sparse resultant elimination theory has provided ways to exploit the structure of polynomials. The sparse resultant first method appeared in Sturmfels and Zelevinsky (1992) [58]. The construction of the sparse resultant formulation is similar to that of Macaulay formulation. Macaulay formulation is based on the Bezout bound on the root count, or the total degree, of a set of polynomials, which is quite loose. Instead, the sparse formulation uses the recently developed, and significantly tighter, BKK bound [1] to construct a smaller resultant matrix than Macaulay s formulation. The sparse resultant formulation is numerically robust and can be highly efficient if the sparse structure is exploited. In recent years, many techniques such as multivariate interpolation, generalized eigenvalue, heuristic search that exploits the sparseness to reduce the matrix size and improve the numeric robustness have been developed. See 9

33 the work of I. Z. Emiris (1999) [12], D. Manocha and J. F. Canny (1993) [37] Contributions In this dissertation, we present a new homotopy solver POLSYS GLP built on the existing FORTRAN code POLSYS PLP by Wise et al. [77]. POLSYS GLP uses generalized linear product (GLP) structure for the start system which exploits the monomial structure of our design equations to significantly reduce the number of homotopy paths that must be tracked to determine the roots of the system. In addition, because this reduced number of paths can still be hundreds of thousands, we parallelized POLSYS GLP using MPI (Message Passing Interface) so that it can run on the parallel distributed memory multiprocessors, such as UCI s Beowulf system and the Blue Horizon system at the San Diego Supercomputer Center. Polynomial homotopy was needed only for the largest of the design problems, there are many sub-cases that are small enough to solve analytically. A sparse matrix resultant formulation was used to solve several of the CS and RPS design cases. 1.4 Computer-Aided Synthesis of Linkages Computer-aided linkage synthesis dates back to the work of Kaufman (1971) [55], who developed the first implementation of computer graphics based mechanism synthesis, called KINSYN. This program gave users the ability to design a planar four-bar linkage interactively. 10

34 1.4.1 Planar Linkages Erdman and Gustafson (1977) [13] introduced LINCAGES-4, which had many of the same features of KINSYN, but also provided a map of linkage solutions to assist the designer. Its successor LINCAGES-6 [5, 45] gave users the ability to design 6-bar linkages. Waldron and Song (1981) [57] introduced RECSYN, which again followed KINSYN but provided the capability to identify rectified solutions, that is those that avoided order and branch problems. Currently, there are two primary commercial linkage synthesis software systems WATT 1.0 [20] by Heron Technologies and SYMECH-4 [66] by SyMech, Inc. Both systems provide the designer the ability to synthesize planar 4-bar, 6-bar and 8-bar linkages Spatial Linkages The first computer aided synthesis package for of spatial linkage design was the Sphinx software by Larochelle (1993) [29] which was limited to the synthesis of spherical 4R linkages. Sphinx used three dimensional high speed graphics, and a map of linkage solutions to assist designers. The successor to Sphinx, was SphinxPC [56] which was designed to run on a standard personal computer and integrated both planar 4R and spherical 4R linkage synthesis. Virtual reality was introduced by Kraal and Vance (2001) [28] in spherical 4R synthesis routine VEMECS. Larochelle (1998) [30] extended his work with spherical 4R chains to spatial 4C linkages with the design system, SPADES. He then teamed with Vance to gener- 11

35 ate the virtual reality based 4C design software, VRSpatial (Vance, Larochelle, and Dorozhkin 2002 [70]) Robots The application of mechanism synthesis theory to robotic system relies on a matching the dimensions of a serial chain to a specific task. This task-based approach to robot system design was introduced by Leger and Bares (1998) [34]. Their design system DARWIN uses a genetic algorithm to identify the robot topology and physical dimensions that best meet the task requirements Contributions In this dissertation, we show that there are over two hundred spatial serial chain topologies that can be designed using the technique of mechanism synthesis. In order to provide a design capability adaptable to this range of serial chain topologies, we developed the Java-based synthesis software Synthetica so that it can integrate user-specified synthesis algorithms. An important feature of this system is an analysis routine that can simulate the movement of robots that have limited mobility due to less than six degree-of-freedom. We address this by introducing a novel analysis routine integrates a singular-valuedecomposition solution with a dual quaternion metric to determine reachable endeffector trajectories that best approximate those desired by the user. 12

36 1.5 Summary of Contributions This dissertation is intended to develop the mathematical and computational tools for the synthesis of spatial serial and parallel robots. The contributions are as follows: An enumeration of the seven five degree-of-freedom serial chains with a spherical wrist, and the constraint equations that characterize them, see [63]; The formulation of all of the special cases for the design of CS and RPS serial chains, including new sparse matrix resultant solutions to the cases CS6 and RPS8, as well as polynomial homotopy solutions to the general cases, see [62, 61]; The formulation of the constraint equations for the PPS, right RRS and RRS serial chains. A complete analytical solution for the PPS chain, and homotopy solution for the general right RRS and RRS synthesis problems, see [63]; A new formulation for the synthesis of the symmetric parallel platform 3RRS and the homotopy solution of the design equations, see [78]; The new homotopy solver POLSYS GLP which implements a general linear product start system and a multi-processor capability to solve the large polynomial systems that arise in the design of CS, PRS, RPS and RRS serial chains, see [64, 63]; The synthesis software Synthetica which implements a new analysis technique 13

37 to simulate the movement of constrained robotic systems, and is designed to included user generated synthesis routines, see [59, 60, 8, 53]. 1.6 Organization The material of this dissertation has been organized in the following way. Chapter 2 contains the kinematics background on describing constrained robotic systems, an enumeration of these systems and a general kinematic analysis routine for simulating their movement. Chapter 3 presents the polynomial homotopy and resultant methods for solving polynomial systems. Chapter 4 derives and solves the synthesis equations for a class of five degree-of-freedom constrained robots. Chapter 5 solves a tailored version of these synthesis problems using homotopy and resultant methods. Chapter 6 presents Synthetica, a general purpose software architecture for synthesis and simulation of constrained robots. Finally, Chapter 7 contains the conclusions and future research. 14

38 Chapter 2 Constrained Robotic Systems 2.1 Overview A robot is usually designed so that it can position its end-effector with a three degree-of-freedom of translation and three degree-of-freedom of orientation within its workspace. The primary concern is the size and shape of the six dimensional workspace. Our goal is to reduce the complexity, and increase the reliability, of the robot by reducing the number of actuators, and at the same time tailoring it to a specific task. The resulting robot design constrains the movement of the end-effector, and we call them constrained robotic systems. In this chapter, we provide the mathematical basis for modeling constrained robots, which allows us to enumerate the available topologies. We then formulate a general system for analyzing and simulating the movement of general constrained robotic systems. We use a novel kinematic solver based on singular-value-decomposition combined with a trajectory planning routine that uses a dual quaternion metric to 15

39 approximate a user-specified trajectory. 2.2 Kinematics Background Kinematic analysis studies the relative motions, such as the displacement, velocity, and acceleration, associated with the links of a given robot. Throughout the development of kinematics, numerous mathematic theories and tools have been introduced and applied. Examples are the 4 4 homogeneous transformation matrices introduced by Denavit and Hartenberg (1955) [10], quaternions and dual quaternions introduced by Yang and Freudenstein (1964) [79], also see Bottoma and Roth (1979) [3] and McCarthy (1990) [40] Homogeneous Transformation It is well known that the coordinate transformation from a moving frame M to a fixed frame F can be represented by a 4 4 homogeneous matrix. Let the (x, y, z) T be the coordinates of a point in the M. Its coordinates (X, Y, Z) T in F can be computed as X x Y = r x r y r z d y, (2.1) Z z 1 1 where r x,r y,r z and d are the axes and origin of the frame M denoted in the frame F respectively. The upper 3 3 sub matrix formed by r x,r y,r z, denoted by [R], is called the rotation matrix. The inverse of R equals its transpose, that is [R] 1 = [R] T. 16

40 A 4 4 homogeneous matrix corresponds a screw displacement along a line in space. In kinematics, the most commonly used are screw displacements about the X and Z axes, defined by a cos θ sin θ cosα sin α 0 sin θ cos θ 0 0 [X(α, a)] =, [Z(θ, d)] =. (2.2) 0 sin α cosα d To complete the list, we also define the screw displacement along Y axis as cosφ 0 sin φ b [Y (φ, b)] =. (2.3) sin φ 0 cosφ Dual Quaternion We now introduce dual quaternion representation for coordinate transformations. Dual quaternions comprise two quaternions ˆQ = (Q, Q 0 ), where Q = (q 1, q 2, q 3, q 4 ) and Q 0 = (q 5, q 6, q 7, q 8 ) are called the real and image part of the dual quaternion respectively. It is well know that we can use dual quaternions to represent a general transformation subject to the following constraints q1 2 + q2 2 + q2 3 + q2 4 = 1 q 1 q 5 + q 2 q 6 + q 3 q 7 + q 4 q 8 = 0. (2.4) Given a 4 4 homogeneous matrix [T] = [R,d], where [R] and d are the rotation and translation part respectively, we can construct the corresponding dual quaternion as follows. First compute the rotation axis s = (s x, s y, s z ) and angle φ from the 17

41 rotation matrix [R] using Cayley s formula (McCarthy 1990 [40]). The real part quaternion Q can then be constructed as Q = (s x sin φ 2, s y sin φ 2, s z sin φ 2, cos φ ). (2.5) 2 The image part quaternion Q 0 is constructed as q 4 q 3 q 2 q Q 0 = (1/2) 3 q 4 q 1 d. (2.6) q 2 q 1 q 4 q 1 q 2 q 3 On the other hand, if we are given a dual quaternion ˆQ subjected to the two constraints (2.4), the 4 4 homogeneous transformation matrix [T(Q)] = [R(Q),d( ˆQ)] can be written as q 1 2 q2 2 q3 2 + q4 2 2(q 1 q 2 q 3 q 4 ) 2(q 1 q 3 + q 2 q 4 ) [R(Q)] = 2(q 1 q 2 + q 3 q 4 ) q1 2 + q2 2 q2 3 + q2 4 2(q 2 q 3 q 1 q 4 ), (2.7) 2(q 1 q 3 q 2 q 4 ) 2(q 2 q 3 + q 1 q 4 ) q1 2 q2 2 + q3 2 + q4 2 and q d( ˆQ) 8 q 7 q 6 q 5 = 2 q 7 q 8 q 5 q 6 q 6 q 5 q 8 q 7 q 1 q 2 q 3 q 4. (2.8) Dual quaternion provides a convenient metric for measuring the distance between two spatial locations (position and orientation). Therefore, it is often used in motion interpolation in space, see Ge and Ravani (1994) [17]. A Bezier motion generation routine using quaternions has been developed to generate design tasks for our synthesis software Synthetica. 18

42 Joint Diagram Symbol DOF Revolute θ R 1 Prismatic Cylindric Universal Spherical θ2 θ d d θ1 θ1 θ2 θ3 P 1 C 2 T 2 S 3 Planar E 3 Table 2.1: The six basic joints Kinematic Joints and Links A robot is a collection of interconnected components, individually called links. The physical connections between links are called joints. Using Denavit-Hartenberg convention [7], the link transformation and joint transformation are defined by the screw displacement along X axis and Z axis respectively defined in (2.2). The common normal between the two joint axes defines the length a and the twist angle α of the link. See Figure 2.1. The two basic types of joints are revolute (R) and prismatic (P) joints which apply the constraints defined by, revolute: [R(θ)] = [Z(θ, )], prismatic: [P(d)] = [Z(, d)]. (2.9) The hyphen denotes parameters that are constant. For our purposes, we include four additional joints that are special assemblies of 19

43 Z1 Link Z2 a d α X θ Figure 2.1: A link connects two joints. R and P joints, Table 2.1. They are: (i) the cylindric joint, denoted by C, which is a PR chain with parallel axes, such that [C(θ, d)] = [Z(θ, d)]; (2.10) (ii) the universal joint, denoted by T, which consists of two revolute joints with axes that intersect in a right angle, that is [T(θ, φ)] = [Z(θ, )][X( π, 0)][Z(φ, )]; (2.11) 2 (iii) the spherical joint, denoted by S, which is constructed from RRR chain with axes that are intersect in a single point, given by [S(θ, φ, ψ)] = [Z(θ, )][X( π 2, 0)][Z(φ, 0)][X( π, 0)][Z(ψ, )]; (2.12) 2 (iv) the planar joint, denoted by E, has several constructions but is equivalent to a PPR chain constructed so the axis of the revolute joint is perpendicular to the 20

44 End-Effector [T E ] Z n Z 1 Z 2 Link 1 Link 2 H Link n-1 θn Xn α1 G a1 d2 X1 θ2 X2 dn Xn-1 Base Figure 2.2: A serial robot is a sequence of links connected by joints. plane defined by the two prismatic joints, given by [E(u, v, θ)] = [Z(, u)][x( π 2, 0)][Z(0, v)][x(π, 0)][Z(θ, )]. (2.13) 2 The joints R, P, C, T, S have be defined as Java classes in Synthetca. The users can conveniently model a mechanism by specifying a topology (a string of joint types). For instance, a string TS denotes a serial chain with an universal joint and a spherical joint connecting the base and the end-effector respectively Kinematic Equation of Serial Robots A serial robot (Figure 2.2) is a sequence of rigid links connected by joints to form a serial open chain. One end is fixed to the base. The other end is equipped with an end-effector. The joints are generally powered and designed to control the position of a link relative to its neighbor. The number of actuators needed to define the configuration of the chain is called its degree-of-freedom (DOF). For serial chains, 21

45 DOF is equal to the number of joints in the chains, counting the DOF of compound joints. The kinematics equation of a serial chain defines the location of the end-effector in terms of the joint parameters, written as [T E ( θ)] = [G][K( θ)][h] = [G][Z(θ 1, d 1 )][X(α 12, a 12 )] [X(α n 1,n, a n 1,n )][Z(θ n, d n )][H], (2.14) where [G] locates the first link relative to the base and [H] locates the end-effector relative to the last link. And the matrices [Z(, )] and [X(, )] denote screw displacements about the Z and X axes, respectively, given by (2.2). The parameters (θ, d) define the movement at each joint and (α, a) are the twist angle and length of each link, collectively know as the Denavit-Hartenberg parameters [7] Kinematic Equation of Parallel Robots A parallel robot (Figure 2.3) is formed by assembling multiple serial chains in parallel with both the base and end-effector bind together. Let the 4 4 homogeneous matrix [T E ] represents the location of the end-effector. The kinematic equation of a parallel robot requires that the end-effectors of the sub chains equal to each other, that is, T E = [G 1 ][K( θ 1 )][H 1 ]. T E = [G m ][K( θ m )][H m ], (2.15) where m is the number of sub chains and θ i is the joint parameters of the ith chain. 22

46 End-Effector [T E ] [H 1 ] [H m ] Platform [G 1 ] [G m ] Base Figure 2.3: A parallel robot formed by m serial chains. 2.3 Enumeration of Constrained Robots This dissertation focuses on the serial and parallel robot with less than six degrees-offreedom, termed constrained robotic systems. In what follows, we first provide an enumeration of constrained serial robots with two to five degrees-of-freedom. Then we enumerate constrained parallel robot using these constrained serial chains as supporting limbs. We assume that each supporting serial chain imposes at least one constraint on the movement of the end-effector. Thus, no supporting chain has six degrees-of-freedom. 23

47 2.3.1 Constrained Serial Robots Using the basic joints R, P, C, T, S and E, it is possible enumerate all serial robots with two to five degrees-of-freedom. Recall that the freedom F of the end-effector of a serial chain is the sum of the degrees-of-freedom f j at each joint. We define degreeof-constraint U = 6 F as the number of constraints on the end-effector imposed by the serial chain, that is a serial chain with n joints has n U = 6 f j. (2.16) If a single R or P joint supports the end-effector, then U=5, and the system cannot have another supporting serial chain because an additional constraint eliminates movement of the end-effector. These two cases are considered to be trivial constrained robots. On the other hand, a serial chain with six or more degrees-of-freedom has U 0, and does not impose any constraint on the end effector. Our interest is in serial chains with degree-of-constraint 1 U 4, that is those that have freedom 2 F 5. We first categorize the supporting serial chains by their degree-of-constraint U. Within each category, we define the class of serial chains based only on the presence of various joints, independent of the order of the joints along the chain. Note that a serial chain can have no more than three prismatic joints. Furthermore, the C and E joints contain the equivalent of one and two prismatic joints respectively, which must be accommodated in the enumeration. After determining all the classes of chains, we permute the joints to obtain various 24 j=1

48 Category Class Chains IV 2R RR (6) RP RP, PR 2P PP C C T T III 3R RRR (18) 2RP RRP, RPR, PRR R2P RPP, PRP, PPR RC RC, CR RT RT, TR 3P PPP PC PC, CP PT PT, TP S S E E II 4R RRRR (51) 3RP RRRP, RRPR, RPRR, PRRR 2R2P RRPP, RPPR, PPRR, PRRP, PRPR, RPRP 2RC RRC, RCR, CRR 2RT RRT, RTR, TRR R3P RPPP, PRPP, PPRP, PPPR RPC RPC, RCP, PRC, PCR, CRP, CPR RPT RPT, RTP, PRT, PTR, TRP, TPR RS RS, SR RE RE, ER 2PC PPC, PCP, CPP 2PT PPT, PTP, TPP PS PS, SP PE PE, EP 2C CC CT CT, TC 2T TT Table 2.2: Serial chains with four, three, and two degrees-of-constraint. 25

49 Category Class Chains I 5R RRRRR (139) 4RP RRRRP, RRRPR, RRPRR, RPRRR, PRRRR 3R2P RRRPP, RRPPR, RPPRR, PPRRR, PRPRR PRRPR, PRRRP, RPRPR, RPRRP, RRPRP 3RC RRRC, RRCR, RCRR, CRRR 3RT RRRT, RRTR, RTRR, TRRR 2R3P PPPRR, PPRRP, PRRPP, RRPPP, RPRPP RPPRP, RPPPR, PRPRP, PRPPR, PPRPR 2RPC RRPC, RRCP, RPRC, RPCR, RCRP, RCPR PRRC, PRCR, PCRR, CRRP, CRPR, CPRR 2RPT RRPT, RRTP, RPRT, RPTR, RTRP, RTPR PRRT, PRTR, PTRR, TRRP, TRPR, TPRR 2RS RRS, RSR, SRR 2RE RRE, RER, ERR R2PC PPRC, PPCR, PRPC, PRCP, PCPR, PCRP RPPC, RPCP, RCPP, CPPR, CPRP, CRPP R2PT PPRT, PPTR, PRPT, PRTP, PTPR, PTRP RPPT, RPTP, RTPP, TPPR, TPRP, TRPP RPS RPS, RSP, PRS, PSR, SRP, SPR RPE RPE, REP, PRE, PER, ERP, EPR R2C RCC, CRC, CCR RCT RCT, RTC, CRT, CTR, TRC, TCR R2T RTT, TRT, TTR 3PT PPPT, PPTP, PTPP, TPPP 2PS PPS, PSP, SPP P2C PCC, CPC, CCP PCT PCT, PTC, CPT, CTP, TPC, TCP P2T PTT, TPT, TTP CS CS, SC CE CE, EC TS TS, ST TE TE, ET Table 2.3: Enumeration of single degree-of-constraint serial chains. 26

50 chains. The number of permutations for each class can be evaluated using the formula n! n R!n P!n C!n T!n S!n E!, (2.17) where n is the number joints in the chain, and n R denotes the number of revolute joints, and so on for the other joints, as well. The result is that we have six serial chains in category IV, 18 in category III, 51 in category II, and 139 in category I; see Tables 2.2 and Constrained Parallel Robots Now we consider a constrained parallel manipulator with 2 m 5 chains, each of which imposes U i constraints, then the mobility M of the end-effector is M = 6 m U i. (2.18) i=1 Notice that the degree-of-constraint C = 6 M of the end-effector can be computed as the sum of the constraints imposed by the individual chains. We can list the parallel assemblies that impose a particular degree-of-constraint by combining chains from the various categories. For example, 4I denotes four supporting chains that impose one degree-of-constraint each. Similarly 2I-1II is a parallel assembly consisting of two chains that impose one constraint each, combined with a third chain that imposes two constraints. Both systems provide the end-effector with two degree-of-freedom of movement. The number of combinations of chains within each assembly category is easily determined. Consider the assembly category 4I consisting of four serial chains each 27

51 Constraints Assembly Categories Total 5 5I, 3I-1II, 2I-1III, 1I-2II, 1I-1IV 487,990, I, 2I-1II, 2II, 1I-1III, 1IV 16,734, I, 1I-1II, 1III 464, I, 1II 9,781 Table 2.4: Enumeration of constrained parallel robots Figure 2.4: A TPR chain imposes two constraints, so a 2TPR spatial linkage has two degrees-of-freedom. of which imposes one constraint. Recall that the number of serial chains in category I is 139. Therefore, the number of assemblies is the combination of m = 4 chains taken from the list of n = 139 with repetitions allowed, which is given by the formula ( ) ( ) n + m = = 16, 234, 505. (2.19) m 4 Applying this formula to each of the various assembly categories yields the total number of two to five degree-of-freedom constrained parallel robotic systems, Table 2.4. Figure 2.4 shows the 2TPR constrained parallel manipulators. Each of the TPR 28

52 Figure 2.5: A RPS chain imposes one constraint, so a 3RPS spatial linkage has three degrees-of-freedom. chain imposes two constraints therefore the parallel system 2TPR has two degreesof-freedom. Similarly in the 3RPS system (Figure 2.4), the individual RPS chains impose one constraint, which means the system 3RPS has three degrees-of-freedom. 2.4 Simulating Constrained Robotic Systems In this section, we propose a kinematics solver for general constrained serial or parallel robots. We also formulate a trajectory planning algorithm that uses dual quaternion as a metric to generate a task for the design process. An optimization based on singular-value-decomposition is used to solve for the robot configuration that comes closest at each frame in a specified trajectory. 29

53 2.4.1 Differential Kinematics of Serial Chains The trajectory of a point p in the end-effector of a constrained robot supported by m serial chains can be computed using the kinematics equations of the ith supporting chain as P(t) = [G i ][K( θ i )][H i ]p, i = 1,...,m. (2.20) The velocity Ṗ of this point is given by Ṗ = v + ω (P d), (2.21) where d is the origin of the end-effector frame M, v is its velocity, and ω is the angular velocity of this frame. The six-vector V = (v, ω) T is related to the joint rates of each supporting chain by the equation V = [J 1 ] θ1 = = [J i ] θi = = [J m ] θm, (2.22) where [J i ] is known as the Jacobian of the ith chain. It is possible to show that the Jacobian for a serial chain with n revolute joints takes form [J i ] = S 1 (d C 1 ) S 2 (d C 2 ) S ni (d C ni ), (2.23) S 1 S 2 S ni where n i is the number of joint variables in the ith supporting chain, S j is the direction of the jth revolute joint axis and C j is a point on this axis, measured in the base frame F. Furthermore, if the jth revolute joint is replaced by a prismatic joint, then the column vector (S j (d C j ),S j ) T is replaced by (S j, 0) T. See Craig (1986) [7] 30

54 and McCarthy (2000) [41]. The joints C, T, S, and E are assemblies of revolute and prismatic joints, therefore the Jacobian for serial chains with these joints have the same structure as equation (2.23) Dual Quaternion Metric Dual quaternion parameters provide a convenient measurement of error between two locations in 3D space. For convenience of programming, we use an eight dimensional vector q = (q 1, q 2, q 3, q 4, q 5, q 6, q 7, q 8 ) to represent the location of the end-effector. The velocity V of the end-effector can be obtained by differentiating the formulation (2.7) and (2.8), written as V = [J E ] q, (2.24) where [J E ] is the 6 8 matrix 2q 8 2q 7 2q 6 2q 5 2q 4 2q 3 2q 2 2q 1 2q 7 2q 8 2q 5 2q 6 2q 3 2q 4 2q 1 2q 2 2q [J E ] = 6 2q 5 2q 8 2q 7 2q 2 2q 1 2q 4 2q 3. (2.25) 2q 4 2q 3 2q 2 2q q 3 2q 4 2q 1 2q q 2 2q 1 2q 4 2q Also the derivatives of the two constraints (2.4), gives 0 0 = 2q 1 2q 2 2q 3 2q q = [C] q. (2.26) q 5 q 6 q 7 q 8 q 1 q 2 q 3 q 4 31

55 2.4.3 Differential Kinematics of Parallel Chains The equations (2.22) and (2.24) together with the differential quaternion constraints (2.26) define the differential kinematics equations for the constrained parallel robots. Approximate the derivatives in these equations to obtain a linearized set of closure equations [J 1 ] 0 0 [J E ] θ 1 E 1 0 [J 2 ] 0 [J E ] θ 2 E =., (2.27) 0 0 [J m ] [J E ] θ m E m [C] q E c which we write as [A] r = E. (2.28) The vectors E i, i = 1,..., m define the difference between the position of the endeffector defined by q and its position defined by joint parameters θ i of the ith chain. We compute E i from the difference of the 4 4 matrices [T( θ i )] = [R( θ i ),d( θ i )] and [T(q)] = [R(q),d(q)], where R and d denote the 3 3 rotation matrix and 3 1 translation vector, respectively. In particular, we have d( E θ i ) d(q) i = φ i (2.29) where φ i is the 3 1 vector constructed from the skew-symmetric part of the matrix [ Φ i ] = [R( θ i ) R(q)][R(q)] T. (2.30) The term E c is the difference between the dual quaternion constraint equations and 32

56 their required values, given by q1 E 2 c = + q2 2 + q2 3 + q2 4 1 q 1 q 5 + q 2 q 6 + q 3 q 7 + q 4 q. (2.31) 8 The coefficient matrix [A] in (2.27) consists of 6m + 2 rows and n = 8 + n i columns, where n i is the number of joint variables in the ith supporting chain as stated before. The difference between these two is the mobility M of the system, that is M = n (6m + 2) = (8 + m n i ) (6m + 2) = 6 The definition of a constrained robot requires that 1 M 5. i=1 m (6 n i ). (2.32) i= Inverse Kinematics The linearized closure equations (2.27) can be used to find the joint parameters for a constrained robot that positions its end-effector at or near a specified goal position, depending on whether this position is inside or outside the workspace of the system. This gives us the flexibility to specify a trajectory for the end-effector of the constrained robot that may pass outside its workspace. We use the singular value decomposition to invert the closure equations (2.27) to determine the correction of variables r. The singular value decomposition of [A] is given by [A] = [U][Σ][V ] T, (2.33) where [Σ] is an m n matrix with the square roots of the eigenvalues of [AA T ], denoted σ i, along its main diagonal and n m columns of zeros. The associated eigenvectors 33

57 form the m m orthogonal matrix [U]. Let r m be the rank of [A], then the first r columns of the n n matrix [V ] are obtained by normalizing the vectors [A] T u i, where u i is the ith column of [U]. The remaining n r columns are constructed by Gram-Schmidt orthogonalization to span R n and define the null-space of [A]. For a given location q of the end-effector and an estimate of the joint parameters, denoted r i, we can solve the closure equations to determine an updated parameter vector, r i+1. This is done by computing the pseudo-inverse of [A] + using the singular value decomposition r i+1 = r i + [V ][Σ] + [U] T E, (2.34) where [Σ] + is the n m matrix with 1/σ i along its main diagonal and n r rows of zeros. This provides the minimum norm solution vector r i+1, which we iterate until the error vector E becomes less than a prescribed tolerance Trajectory Planning In order to plan the movement of a constrained robotic system, the user specifies a trajectory [T(t i )] consisting of a set of positions obtained by key frame interpolation, where i = 1,...,N denotes the interpolation frame count. Our goal is to have the end-effector of the constrained robot follow this trajectory as closely as possible. For each frame [T(t i )] let g i be the associated dual quaternion. We seek the endeffector position q i that minimizes q i g i, which is the same as minimizing the 34

58 Figure 2.6: Flowchart of the trajectory planning algorithm. 35

59 objective function, f(q i ) = 1 2 (q i g i ) (q i g i ), (2.35) subject to constraints imposed by the kinematics equations (2.27). The gradient of the objective function f(q i ) yields f(q i ) = q i g i, (2.36) which we project onto the null space of the constraint equations defined by [A] in equation (2.27). The negative of the gradient f is the direction in which the objective function f(q i ) decreases. The null space of [A] defines the feasible directions for changes to the parameter vector r. This null space is obtained from the singular value decomposition (2.33) as the last n r column vectors of the matrix [V ]. Denote these orthonormal vectors as w j, j = 1,..., n r, so we have the n (n r) matrix [W]. The projection of f onto this null space is a = [W] T (g i q i ), (2.37) where g i and q i are augmented by n 8 zeros. The result is the incremental parameter vector r = [W]a. We then use the numerical inverse kinematics (2.34) to update the parameter vector r so that it satisfies the constraint equations. This procedure is iterated until the objective function reaches a local minimum. See Figure 2.6. This algorithm has been integrated into our synthesis software Synthetica. 36

60 joint α a θ d θ π/2 0 θ π/4 1 0 d 3 4 π/4 1 θ 4 0 Table 2.5: The Denavit-Hartenberg parameters for the TPR chain. x y z Long. Lat. Roll G H G H Table 2.6: The base and end-effector frames of a 2TPR system Numerical Examples 2TPR system To demonstrate this algorithm, we consider a 2TPR constrained parallel robot shown in Figure 2.4. The Table 2.5 defines the Denavit-Hartenberg parameters for the two TPR chains. The locations of the base and end-effector frames for these two chains are specified by the translation vector and three angles given in Table 2.6. The trajectory planning result is shown in Figure 2.7. The darker trajectory is specified by Bezier interpolation of key-frames at the beginning and the end and one in the center. Notice that initial and final positions are reachable by the 2TPR manipulator, but that the remainder of the trajectory is outside the workspace of 37

61 Figure 2.7: Example of the trajectory of a 2TPR linkage that approximates a specified trajectory. joint α a θ d θ π/2 0 0 d θ π/2 0 θ π/2 0 θ 5 0 Table 2.7: The Denavit-Hartenberg parameters used for the RPS chain. this system. The lighter color trajectory denotes the approximation to this path as determined by the planning algorithm. 3RPS system Another example of a constrained parallel manipulator is defined by the 3RPS system shown in Figure 2.5. The Denavit-Hartenberg parameters of the three supporting serial chains are given in Table

62 x y z Long. Lat. Roll G H G H G H Table 2.8: The base and end-effector frames of a 3RPS system. Figure 2.8: Example of the trajectory of a 3RPS linkage that approximates a specified movement. The trajectory planning result is shown in Figure 2.8. As in the previous example the darker trajectory is specified by Bezier interpolation of a set of key-frames. The lighter trajectory is the approximation that is reachable by the 3RPS manipulator. 39

63 2.5 Summary In this chapter, we have reviewed the kinematics background for studying the constrained robotic systems. An enumeration shows that there are 214 serial chains and over four hundred million parallel chains constructed from them. To animate the movement of these systems, we have developed a general kinematic solver and a trajectory planning routine which have been integrated into our design software Synthetica. 40

64 Chapter 3 Roots of Polynomial Systems 3.1 Overview In this chapter, we present the mathematical background for the solution of the polynomial systems that arise in our design of constrained robots. Our goal is to find all of the roots of a system of polynomials, therefore we begin with strategies for determining bound on the number of roots. We then present two ways to find these roots, a numerical method called polynomial homotopy and an algebraic technique called resultant elimination. Since the efficiency of a polynomial homotopy algorithm depends on construction of the start system, we describe four linear product base ways to construct a start system: 1-homogeneous, m-homogeneous, partitioned linear product (PLP), general linear product (GLP). For our synthesis problems, we found that the general linear product provided the best model for the start system. This was implemented in a homotopy solver POLSYS GLP. 41

65 When synthesis problems are small enough, we used resultant elimination to find analytical solutions for up to 64 roots. Therefore, we present the solution of polynomial systems using resultants, and then solve general examples of our synthesis equations using sparse matrix resultants. 3.2 A Polynomial System Let P(z) = 0 be a polynomial system of n equations in n unknowns z = (z 1, z 2,..., z n ), written as [ n i P(z) : p i (z) = c ij n j=1 k=1 z k d ijk ] = 0, i = 1,...,n, (3.1) where coefficients c ij are complex constants (and usually assumed to be different from zero) and the d ijk are nonnegative integers. The power products n k=1 z k d ijk are called monomials. We define ML pi as the list of all monomials contained in the polynomial p i, that is ML pi = j ( n d z ijk k ) (3.2) The degree of a monomial is the sum of the exponents in terms of the variables z. The degree of a polynomial p i is the maximum degree of its monomials, defined by d i = max 1 j n i k=1 n d ijk, (3.3) and the total degree of a polynomial system is the product of the degree of each k=1 polynomial, that is d = n d i. (3.4) i=1 42

66 Example: p 1 (x, y) = x 2 + 2x 2 y + y 1 p 2 (x, y) = x 2 + 2xy 3x + y 1 (3.5) is a polynomial system in (x, y). x 2 y is a monomial of p 1. And 2 is its corresponding coefficient. The degree of two polynomial equations are d 1 = 3, d 2 = 2. And the total degree of the polynomial system is d = d 1 d 2 = Homogenization Define P (w) to be the homogenization of P(z): P (w) : p i (w) = w n+1 d i p i ( w 1 w n,..., ), i = 1,..., n, (3.6) w n+1 w n+1 by substituting z i with w i /w n+1 in (3.1). The new set of n + 1 variables w = (w 1,..., w n+1 are called homogeneous variables. The formula P (w) is also called 1-homogenization of P(z) because only one more variable is introduced. Because of its homogeneity, if w is a solution to P (w) = 0, so is aw where a is a constant. We call a solution w with w n+1 = 0 a solution at infinity and a finite solution otherwise. It is not hard to show that the finite solutions to homogeneous equations P (w) = 0 correspond to the solutions of in-homogeneous equations P(z) = 0. The 1-homogenization can be generalized into m-homogenization by first partitioning the n unknowns z are into m sets F = {S 1,..., S j,..., S m, (3.7) 43

67 where m j=1 S j = {z 1, z 2,...,z n, and S j are exclusive sets, that is S j S k = for j k. Suppose each subset S j of z is given as S j = {z j1,..., z jnj, j = 1,...,m (3.8) where n j is the number of elements in the jth set. Notice m j=1 n j = n. We then homogenize each subset S j using 1-homogenization formula by substituting z jk = w jk w jnj +1, that is S j = { w j1,..., w jnj +1 w jnj w jnj +1, j = 1,...,m. As a result, we can write the m-homogenization of p i (z) as p i(w) = ( m j=1 w jnj +1 d ij ) p i ( w jk ), i = 1,...,n, (3.9) w jnj +1 where w are n+m homogeneous variables and d ij is the degree of the equation i with respect to the variables of set j. Example: The 1-homogenization of p 2 in (3.5) can be written as p 2 (X, Y, W) = X2 + 2XY 3XW + Y W W 2 where we have substituted x = X/W, y = Y/W in p 2 (x, y) Root Counting One fundamental question for polynomial systems is on the root count. As we know, a generic linear system has an unique solution and an univariate polynomial equation 44

68 has as many roots as its degree counting multiplicity. In the multivariable case, the Bezout theorem states that the number of roots is bounded by its total degree, called Bezout number. Theorem 3.1 (Bezout) There are no more than d isolated solutions to P(z) in P n, where d is the total degree of P(z). Let P (w) be the homogeneous version of P(z). The number of solutions to P(z) is equal to the number of finite solutions of P (w). If P (w) = 0 has only a finite number of solutions in P n, it has exactly d solutions, counting multiplicity. However very often Bezout number over-estimates the root count because there exist many solutions at infinity. More refined estimates of the number are possible by considering the structure of these polynomials. To do this, one compiles a list of the monomials that appear in each polynomial of the system. The collection of n lists of monomials forms the monomial structure of the system. It is a fundamental result in algebraic geometry that polynomial systems that have the same monomial structure and differ only in the scalar coefficients of the monomials, form a family for which almost all members have the same number of solutions over the complex numbers. We call this the generalized Bezout number of the family. Exceptional members of the family cannot have more than this number of isolated solutions; that is, the Bezout number is a bound on the number of isolated solutions, or roots. Bernstein (1975) [1] shows the root count for any monomial structure can be obtained from the mixed volume of the associated Newton polytopes. This result sometimes is known as the BKK bound. A special case of BKK bound is known as 45

69 linear product decomposition (LPD) bound. A polynomial has a product decomposition if each of its monomial can be obtained as a product of one element from each of two or more factor lists of monomials. If the monomials in these factor lists have degree at most one, then the product decomposition is linear, also called a set structure by Verschelde and Haegemans (1993) [73]. The important result is that a root count generated from the product decomposition is the same as that for the original list. The linear product decomposition allows the determination of the number of roots by tabulation of all ways of choosing one linear factor from each equation such that all the variables are determined and, equivalently, none is over-determined. Each admissible set of linear factors defines a single root. For notational convenience, let x, y, 1 represent the set of linear combinations of parameters x, y and 1, which means a typical term is αx + βy + γ x, y, 1, where α, β and γ are arbitrary constants. Using this notation, we define the product of x, y, 1 u, v, 1 as the set of linear combinations of the product of the elements of the two sets, that is x, y, 1 u, v, 1 = xu, xv, yu, yv, x, y, u, v, 1. (3.10) This product commutes, which means x y = y x, and it distributes over unions, such that x y x z = x ( y z ) = x y, z. Furthermore, we represent repeated factors using exponents, so x, y, 1 x, y, 1 = x, y,

70 It can be proven that a l variable set v of degree µ v x 1, x 2,...,x l, 1 µ (3.11) has ( ) l+µ l monomials. Example: consider a pair of quadratic equations c 11 + c 12 x + c 13 y + c 14 x 2 + c 15 xy = 0 c 21 + c 22 x + c 23 y + c 24 x 2 + c 25 xy = 0, (3.12) where c ij are general coefficients. Both equations have the monomial structure 1, x, y, x 2, xy which has the linear product decomposition 1, x, y, x 2, xy = 1, x 1, x, y, therefore the pair of equations (d 11 + d 12 x)(d 13 + d 14 x + d 15 y) = 0 (d 21 + d 22 x)(d 23 + d 24 x + d 25 y) = 0, (3.13) with d ij as general coefficients, has the same root count as (3.12). While there are four ways to choose one linear factor from each of the two equations in (3.13), only three such choices give a root of the system. The simultaneous choice of both linear factors in x is not admissible, because in general these give distinct solutions for x and hence have no common solution. Thus, the system (3.13) has a Bezout number of three, and by the product decomposition theory, so does system (3.12). If, instead of system (3.12), we had a system of two general quadratic polynomials in two variables, the monomial structure would be 1, x, y, x 2, xy, y 2 = 1, x, y 2. This has four roots, in agreement with Bezout s theorem. The reduction from four to three roots for system (3.12) results from the fact that y 2 is missing in both equations. 47

71 3.3 Polynomial Homotopy Method Polynomial homotopy method is a probability-one numerical method for obtaining all isolated solutions to polynomial systems. Starting at the roots of the start system which are known, the homotopy tracks down to the roots of the target system by following the solution path of a homotopy function which transforms the start system into the target system Homotopy Function The homotopy function provides a way of tracking the solutions of the start system to those of a target system. Given a target polynomial system of n variables P(z), we define the homotopy function by H(λ,z) = (1 λ)q(z) + λp(z), (3.14) where λ [0, 1) is the real-valued homotopy parameter, Q(z) is the start system. The coefficients of both P(z) = 0 and Q(z) = 0 are complex. Therefore, the homotopy H(λ,z) must be viewed as an array of n complex functions in n complex variables z together with a single real variable λ. When λ = 0 and λ = 1, the solutions to H(λ,z) = 0 are the solutions to the start system Q(z) = 0 and our target system P(z) = 0 respectively. 48

72 solutions at infinity Q(z)=0 3 P(z)=0 2 z=a j 1 γ a : H(λ, z)=0 z a λ=0 λ=1 Figure 3.1: Homotopy path tracking Path Tracking For each root of the start system Q(z) = 0, denoted z = a j, j = 1,..., N, the homotopy equation H(λ, z) = 0 has an associated homotopy path, also called zero curve, γ a, which is the connected component of H 1 (0) containing the start point (0,a j ). The zero curve leads either to a point (1,z a ) where P(z a ) = 0, or diverges to a root at infinity. Figure 3.1 shows that path 1 to 4 converge to a solution of the target system and path 5 and 6 diverge to infinity. Each zero curve can be parameterized by its arc length s, so γ a has the form (λ(s),z(s)). Tracking this curve involves numerical computation of points y i (λ(s i ),z(s i )), where {s i is an increasing sequence of arc lengths. This can be done using a predictor-corrector strategy described in Watson et al. (1997) [76] and Wise 49

73 et al. (2000) [77]. Along the zero curve γ a, we have H(λ(s),z(s)) = 0, therefore we can compute d [ ] ds H(λ,z) = dλ/ds H λ Hz = 0, (3.15) dz/ds where [J H ] = [H λ, Hz] is the n (n+1) matrix of partial derivatives of the homotopy H(λ,z). Notice that the vector v = (dλ/ds, dz/ds) T tangent to the zero curve γ a is in the null space of the Jacobian matrix [J H ]. This null space has dimension one by the theory of polynomial homotopy maps (Wampler et al. 1990[74] and Wise et al. 2000[77]). The unit tangent vector v i, in the direction of increasing arc length, at a point y i on γ a is used to predict a value for the next point y 0 i+1, that is y 0 i+1 = y i + (s i+1 s i )v i, (3.16) where s i+1 s i is a chosen arc length step. The predicted value of y 0 i+1 is corrected using the Taylor series expansion of the homotopy given by H(y 0 i+1) + [J H (y 0 i+1)](y 1 i+1 y 0 i+1) 0, (3.17) which yields the correction formula y 1 i+1 = y0 i+1 [J H(y 0 i+1 )] H(y 0 i+1 ). (3.18) The dagger denotes the Moore-Penrose pseudoinverse of the n (n + 1) Jacobian matrix. Geometrically, iteration of the correction formula moves y k i+1 toward the zero curve γ a along a normal direction, and is termed the normal flow algorithm. 50

74 The predictor can be improved by interpolation at previous computed points along the zero curve, and a projective transformation can be used to bound the arc length of all of the paths so that none diverge to infinity. Finally, an end-game strategy can improve the calculation of y near λ = Linear Product Based Start Systems One challenge of homotopy method is on the determination of a valid start system with a small root count. A valid start system must cover all the monomials of the target system, and have known set of roots. A particular convenient way to construct a start system with known roots is using the product of the linear factors. For notational convenience, we introduce the mask S = {s 1,..., s n constructed from n 1s and 0s in order to identify the unknowns in z = {z 1, z 2,...,z n that appear in a specific variable set. For example, the mask of the variable set {z 2, z 4 with full list of variables z = {z 1, z 2, z 3, z 4 is denoted by S = {0, 1, 0, 1. Let S ij = {s ij1,...,s ijn be the mask of the jth linear set of ith polynomial of the start system, d ij be the associated set degree, and m ij n be the number of variables in the set or the number of 1s in S ij. With all this done, we can write a linear product based start system as ( n i n ) dij Q(z) : q i (z) = a ijk s ijk z k 1, i = 1,...,n, (3.19) j=1 k=1 where n i is the number of sets in q i (z) and the coefficients a ijk are randomly specified 51

75 complex numbers. The homotopy program takes one factor from each q i to form a n by n linear system of which solutions provide the start point of the path tracking algorithm. Since variables can be missing in a set, for some combinations, the linear system can be singular. Therefore no path tracking is needed. In what follows, we present four linear product based methods for constructing a start system. They are 1-homogeneous, m-homogeneous, partitioned linear product (PLP), general linear product (GLP), in the order of ascending generality. 1-Homogeneous In the 1-homogeneous start system, all polynomial q i (z) have an unique linear set {z 1, z 2,..., z n with set degree d i (degree of p i ). That is, the parameters are specialized to n i = 1, d ij = d i, S ij = {1, 1,..., 1, where i = 1,..., n and j = 1. As a result, the start system (3.19) can be simplified to the 1-homogeneous start system as ( n ) di Q(z) : q i (z) = a ik z k 1, i = 1,...,n. (3.20) k=1 The number of roots to Q(z) gives the 1-homogeneous Bezout number d = d i i=1 which is simply the total degree of our target system P(z). 52

76 Example: consider two polynomial equations p 1 = c 11 xy + c 12 x + c 13 (3.21) p 2 = c 21 xy + c 22 x + c 23 where c ij are nonzero complex coefficients. The 1-homogeneous start system can be written as q 1 = (a 11 x + a 12 y) 2 1 q 2 = (a 21 x + a 22 y) 2 1 (3.22) which gives the 1-homogeneous Bezout number as 2 2 = 4. Therefore four homotopy paths have to be tracked to obtain all solutions to the target system. m-homogeneous In m-homogeneous start system, we partition the unknowns z into m sets. For each set, we construct a linear factor. All start polynomials q i (z) have the same m linear factors with only coefficients different. Therefore, we have the following specializations: n i = m n, d ij d i, S ij = S j = {s j1,..., s jn, m S j = {1, 1,..., 1, where i = 1,..., n and j = 1,...,m. The associated set degree d ij is determined by considering the degree of those variables in the jth set for the polynomial p i. The m-homogeneous start system is simplified as ( m n ) dij Q(z) : q i (z) = a ijk s jk z k 1, i = 1,...,n. (3.23) j=1 k=1 The root count of Q(z) gives the m-homogeneous Bezout number which is determined by the coefficient of the term m j=1 αm j j j=1 in the product n i=1 ( m j=1 d ijα j ), where m j is the number of variables in the jth set, or the number of 1s in S j. 53

77 Example: consider the same two equations in (3.21) and partition the variables into two sets {x, {y. Thus, the 2-homogeneous start system is written as q 1 = (a 11 x 1)(a 12 y 1) q 2 = (a 21 x 1)(a 22 y 1) (3.24) We have m 1 = m 2 = 1, d 11 = d 12 = d 21 = d 22 = 1. The 2-homogeneous Bezout number is the coefficient of α m 1 1 α m 2 2 = α 1 1α 1 2 in the product (d 11 α 1 + d 12 α 2 )(d 21 α 1 + d 22 α 2 ) = (α 1 + α 2 )(α 1 + α 2 ), which is 2. This tells us that equations (3.21) have no more than two solutions. Also if using the 2-homogeneous start system (3.24), only two homotopy paths have to be tracked. Partitioned Linear Product In m-homogeneous formulation, all polynomial p i (z) have the same partition. However, in partitioned linear product (PLP) formulation, each p i (z) can have a different partition. That is we have the following specializations: n i n, d ij d i, n i j=1 S ij = {1, 1,..., 1, where i = 1,..., n and the set degree d ij is determined similarly as in the m- homogeneous formulation. The start system is in form of (3.19). Example: consider the following two equations p 1 = c 11 xy + c 12 x + c 13 (3.25) p 2 = c 21 x 2 + c 22 xy + c 23 54

78 If we choose the partition {x), {y and {x, y for p 1 and p 2 respectively, the PLP start system can be written as q 1 = (a 11 x 1)(a 12 y 1) q 2 = (a 21 x + a 22 y) 2 1, (3.26) from which we can obtain the PLP Bezout number as B PLP = 4. Therefore four paths have to be tracked. Generalized Linear Product The generalized linear product (GLP) structure is an extension of the PLP structure. In PLP, all the sets in each partition are exclusive, therefore the number of sets in a partition can not be more than the number of variables n. However, in GLP, the set are not exclusive. The number of sets can not be more than the degree d i of the ith polynomial. That is, we have the following conditions n i d i, d ij d i, and generally n i j=1 S ij {1, 1,..., 1 where i = 1,...,n and the set degree d ij is determined by considering the degree of the variables in the set S ij. The start system has been given in (3.19). Example: consider the same set of two equations in (3.25) and notice that p 2 is actually linear in y, we construct a GLP start system as q 1 = (a 11 x 1)(a 12 y 1) q 2 = (a 21 x + a 22 y + a 23 )(a 24 x + a 25 ), (3.27) from which we obtain S 11 = {1, 0, S 12 = {0, 1, S 21 = {1, 1, S 22 = {1, 0 and the GLP Bezout number as B GLP = 3. Therefore only three homotopy paths have to be 55

79 Figure 3.2: Flowchart of POLSYS GLP homotopy solver. tracked POLSYS GLP Homotopy Solver In this section, we describe the homotopy solver POLSYS GLP which is a modified version of POLSYS PLP (Wise et. al 2000 [77]) designed to implement GLP start systems. This new solver uses MPI (Message Passing Interface) routines to distribute path tracking among multiple processors. 56

80 Organization The main process of POLSYS GLP is called MAIN TEMPLATE which uses NAMELIST to read in the target polynomial system and the GLP structure data from the file INPUT.DAT. See Figure 3.2. The process allocates memory and then calls the main subroutine POLSYS GLP to formulate start system and track the homotopy paths to the roots of the target polynomial system. These roots are output with solution statistics to the file OUTPUT.DAT. The subroutine POLSYS GLP calls INIT GLP to formulate the GLP start system, and then calls routine BEZOUT GLP to first check the validity of the start system (CHECK GLP) and then to determine its Bezout GLP number. A start system is valid if it includes all of the monomials found in the target polynomial system. The start system is said to cover the target system. At this point, if the start system is valid, the solver enters its main loop, which generates and tracks a homotopy path. The process begins by extracting a linear factor from each polynomial in the start system. This forms a linear system, which, if it is non-singular, defines a root that becomes the initial condition for a homotopy path. An ordinary differential equation solver is used to track the path until it either arrives at a root of the target polynomial or diverges to infinity. The Verification of GLP Start Systems In order to execute POLSYS GLP, the user provides in a data file both the target polynomials and their associated GLP structure, which are used to construct the 57

81 start system. If there is an error and the polynomial does not actually lie in the span of the specified GLP structure, then the homotopy is meaningless. Therefore, it is imperative to verify the GLP structure as follows. For each polynomial p i, we check that each monomial z 1 α 1 z 2 α2 z n α n is contained in the associated linear product decomposition m i j=1 s ij1z 1,..., s ijn z n, 1 d ij. Our approach is to create a set structure table that has the linear terms of s ij1 z 1,..., s ijn z n, 1 as its column headings, and the factors of the expanded monomial z 1 α 1 z 2 α 2 z n α n as its rows. This set structure table has as many columns as the total degree d i of p i, and as many rows as the total degree of the monomial, which must be less than or equal to d i. The defining characteristic of a linear product decomposition is that each factor of the expanded monomial arises from a different linear term in the decomposition. This means that each row of the set structure table must be assignable to a separate column. If this assignment does not exist then the linear decomposition is invalid. We begin with the first row and search the columns left to right to find a linear term (column) that contains the associated monomial factor (row). This column number is saved in a list that denotes the linear terms that have been taken. The row is incremented and the search applied to the columns that have not been taken. When the final row is assigned to an available linear term the verification for the monomial is complete. If a row is found to have a factor that cannot be assigned to a linear term, then 58

82 the assignment of the factor in the previous row is advanced to the next linear term (column) in which it is contained. This step continues until either all of the factors are assigned to separate columns, or there is no available assignment for the factor in the first row. If this occurs then the monomial is not contained in the span of the linear product decomposition. This procedure has been implemented in the subroutine CHECK GLP. Usage In order to execute POLSYS GLP, the user generates an input file, INPUT.DAT, that lists the target polynomial system and the GLP structure. The format for the input file is described in Appendix A. This appendix also provides a Mathematica routine that can be used to automatically generate this input file. The execution of POLYS GLP results in an OUTPUT.DAT file that contains the roots that were computed as well as statistics regarding its execution. See Appendix A for a complete user s guide on how to run POLSYS GLP. Parallel Implementation The solution of our design requires tracking over 800,000 homotopy paths. Our initial single processor computations allowed us to estimate that we could computer approximately 800 paths/hour which means the computation could take 1000 hours or 40 days. Because these calculations are independent, they can be distributed among different processors in a parallel computing cluster. 59

83 Figure 3.3: Parallel path tracking with MPI. The POLSYS GLP solver was adapted for parallel computing using the MPI-2 (Message Passing Interface) routines described by Gropp et al. (2000) [19]. See Figure 3.3. The basic strategy is to distribute an identical set of POLSYS GLP routines among each of n 1 slave processing processors, numbered r = 1,..., n 1. The number r is called the rank of the processor. The processor of rank 0 is the master processor. Each of the processors executes the same basic code. They all read the input data 60

84 file using the parallel I/O routines provided by MPI. Then, slave processors execute a loop consisting of a request to the master processor for a path index, which identifies the root that begins a particular zero curve. The slave processor traces the homotopy path, reports the results to the master processor and requests another path index. The master processor receives the requests by the slave processors, identifies the rank of the requesting processor, distributes the next path index, and sends a stop code when all the paths are traced. The master also accumulates all the roots and path statistics (error flags, arc length, number of function evaluations, projective coordinates) from the slaves and writes the file OUTPUT.DAT. This combines with the duration and variability of path tracking times on each slave processor to ensure that the master is not a bottleneck even for hundreds of slave processors. 3.4 Resultant Elimination Methods Because polynomial homotopy method is computationally demanding, resultant method is preferable when online computation is required Resultant Elimination Steps for Solving Polynomial Systems Given a polynomial system of unknowns z = (z 1, z 2,...,z n ) [ n i P(z) : p i (z) = c ij n j=1 k=1 z k d ijk ] = 0, i = 1,...,n. (3.28) We use the following steps to solve the polynomial system P(z). 61

85 Step 1. Select one variable, say z n, as the suppressed variable (the other variables z = (z 1, z 2,...,z n 1 ) are to be eliminated). And rewrite polynomials p i (z) in terms of z as [ ] n i n 1 P(z ) : p i (z d ) = a ij (z n ) z ijk k = 0, i = 1,..., n, (3.29) j=1 k=1 Step 2. Define all the monomials (power products) of the variables z as new independent unknowns. Step 3. Apply algebraic operations on the polynomials p i (z ) to generate new polynomials Q(z ) : q j (z ) = F(P(z )), j = 1,...m, (3.30) where F( ) represents algebraic operations. This step is the most important step of the resultant formulation. The following section provides various ways to generate new polynomials Q(z ). The solution to new equations Q(z ) is a superset of the solution to the original system P(z). Step 4. Let ML Q be the monomial list of Q(z ) which is of length m. Rewrite (3.30) in matrix form as q 1 (z ) f 1,1 (z n ) f 1,2 (z n ) f 1,m (z n ) 0 q 2 (z ) f = 2,1 (z n ) f 2,2 (z n ) f 2,m (z n ) ML Q (z ) =. (3.31)... q m (z ) f m,1 (z n ) f m,2 (z n ) f m,m (z n ) 0 We define the resultant R P (z n ) as the determinant of the coefficient matrix in (3.31). To check the independency of the selected polynomials, we can substitute a random 62

86 value for z n in the resultant R P (z n ) and check rank deficiency. However if we can not find such a set of m polynomials, we have to go back Step 3 and generate more equations. Step 5. The resultant R P (z n ), is a polynomial of z n which is expressed in terms of their coefficients a ij (z n ). Its vanishing is a necessary condition for the existence of solutions to P(z) = 0. Expanding the resultant yields an univariate polynomial in z n, called characteristic polynomial, h(z n ) = c 0 z n d + c 1 z n d c d, (3.32) where d is the degree of the characteristic polynomial, also the upper bound on the root count to the polynomial system P(z) = 0. Since expanding a matrix polynomial can be time consuming and numerically unstable, we can avoid this by generalized eigenvalue techniques. See Section for details. Step 6. Substitute the roots of the suppressed variable z n, one at a time, into the resultant matrix R P (z n ) and solve the rest variables z in the Step 3. This step only involves of solving the linear system (3.31). This step can also be transferred to eigen system problem. More specifically, the solutions to the monomials in the list ML Q (z ) correspond to the eigen vectors of the resultant matrix R P (z n ). Again see Section for details. 63

87 3.4.2 Resultant of a Polynomial System The computation of resultants typically relies on obtaining matrices in (3.31) whose determinant is either the exact resultant polynomial or, more generally, a nontrivial multiple of it. Essentially, these matrices are sufficient for solving polynomial systems, since the rest of work lies in the scope of linear algebra. In what follows, we focus on methods for constructing such matrices. Resultant of a Linear System One of the simplest cases is when all polynomials are of total degree 1, which corresponds to a linear system p 1 = c 1,1 z 1 + c 1,2 z c 1,n 1 z n 1 + (c 1,n z n + c 1,n+1 ) p P(z 2 = c 2,1 z 1 + c 2,2 z c 1,n 1 z n 1 + (c 2,n z n + c 2,n+1 ) ) :. p n = c n,1 z 1 + c n,2 z c 1,n 1 z n 1 + (c n,n z n + c n,n+1 ), (3.33) where c ij are constant coefficients, z = (z 1,...,z n 1 ) and z n is the suppressed variable. Notice that the polynomial system P(z ) contain only n monomials, that is ML P = {1, z 1,..., z n 1. Therefore P(z ) are enough to construct the resultant matrix. We rewrite the linear system (3.33) in the matrix form as p 1 c 1,1 c 1,2 c 1,n z n + c 1,n+1 p 2 c = 2,1 c 2,2 c 2,n z n + c 2,n p n c n,1 c n,2 c n,n z n + c n,n+1 z 1 z 2. z n 1 1 (3.34) 64

88 The resultant R P (z n ) of the linear system is defined as the determinant of the above coefficient matrix. By linear algebra R P (z n ) can be further written as c 1,1 c 1,2 c 1,n c 1,1 c 1,2 c 1,n+1 c R P (z n ) = z n 2,1 c 2,2 c 2,n c ,1 c 2,2 c 2,n = 0, (3.35). c n,1 c n,2 c n,n c n,1 c n,2 c n,n+1 where we can obtain the unique solution of z n. One can easily verify the result using Vandermnode determinant. Sylvester Resultant Now we consider two polynomial equations p 1 (x, y), p 2 (x, y). Suppress y and suppose p 1, p 2 are of degree l and m in x respectively, that is p 1 (x) = a 0 (y)x l + + a l (y) = 0 P(x) : p 2 (x) = b 0 (y)x m + + a m (y) = 0, (3.36) where coefficients a i and b i are functions of y as shown. We multiply p 1 and p 2 by the monomial list G 1 = {1, x, x 2,...,x m 1 and G 2 = {1, x, x 2,...,x l 1 respectively to obtain total l + m equations Q(x) : q j (x) : G 1 p 1 = {1, x, x 2,...,x m 1 p 1 j = 1,...,m q j (x) : G 2 p 2 = {1, x, x 2,...,x l 1 p 2 j = m + 1,..., m + l. (3.37) which contain the monomials ML Q = {1, x, x 2,...,x l+m 1. Rewrite Q(x) in matrix 65

89 form as p 1 a 0 a 1 a l xp 1 0 a 0 a l 1 a l x m 1 p a = 0 a 1 a l p 2 b 0 b 1 b m xp 2 0 b 0 b m 1 b m x l 1 p b 0 b 1 b l 1 x. x l+m =. 0 (3.38) The resultant of the polynomial system (3.36) is the determinant of the above coefficient matrix, that is a 0 a 1 a l a 0 a l 1 a l a R P (y) = 0 a 1 a l. (3.39) b 0 b 1 b m b 0 b m 1 b m b 0 b 1 b l R P (y) = 0 is the sufficient and necessary condition for p 1 and p 2 to have common roots. The resultant (3.39) is called Sylvester resultant. See reference [9] for a modern description of Sylvester resultant. Nowadays most computer algebra systems including Mathematica and Maple integrate Sylvester resultant formulation. 66

90 Sparse Resultants F.S Macaulay (1902) [36] generalized Sylvester s formulation to multivariate case by seeking for a multiplier list G i for each polynomial p i. He formulated the resultant in the ratio of two determinants M / N, where N is a submatrix of M. The size of matrix M is ( ) ν+n n, where ν = n i=1 d i n. This result is known as Macaulay s matrix. The limitations on Macaulay s formation lie on that the determinants M and N can be identically zero and the division cannot be carried out. This is because Macaulay s formation treated the polynomials in general form without considering coefficient specializations. Recently Macaulay s work has extended to the theory of the so-called sparse resultant, which exploits the structure of the given polynomials. Essentially, sparse resultant is based on BKK bound, which is tighter than Bezout bound (the total degree) which Macaulay s formulation is based on. This leads to stronger algebraic and combinatorial results in general. As a result the size of resultant matrix can be smaller than Macaulay s matrix. The construction of the sparse resultant is similar to that of Macaulay s formulation. Given a set of n polynomials p i (z), we generate new polynomials by multiplying each polynomial with a monomials list G i. Suppose z = (z 1,...,z n 1 ) be the variables to eliminated, z n be the suppressed variable. Let m i be the number of entries 67

91 in G i. The generated polynomials are specifically written as q j (z) : G 1 p 1 j = 1,...,m 1 q Q(z j (z) : G 2 p 2 j = 1 + m 1,...,m 2 + m 1 ) :.. q j (z) : G n p n j = 1 + n 1 i=1 m i,..., n i=1 m i. (3.40) Let m = n i=1 m i and ML Q of length m be the monomial list of Q(z ). Thus we can rewrite Q(z ) in matrix form by treating the monomials ML Q as linearly independent variables. The elements of the m m coefficient matrix R P (z n ) are functions of the suppressed variable z n. However the multiplier lists G i must be chosen such that two requirements are satisfied. One the coefficient matrix is square that is m = m. Second the matrix R P (z n ) must have full rank for arbitrary value of z n Computing Resultant Using Generalized Eigenvalue Techniques Once a valid resultant matrix has been established, the solutions to the suppressed variable can be found by solving the characteristic polynomial which is obtained by expanding the determinant of the resultant matrix. However this process is not only inefficient but also numerically unstable. Fortunately, this can be avoided by reformulating the resultant as a generalized eigenvalue problem and finding the roots using eigenvalue solution techniques. 68

92 Generalized Eigenvalue Problem Given an n n matrix A and B, its generalized eigenvalues and eigenvectors are defined by Ax = λbx, where λ is the eigenvalue and x 0 is the corresponding eigenvector. The eigenvalues correspond to the roots of the determinant A λb = 0. When B is non-singular and its condition number is low enough, the problem can be reduced to an eigenvalue of the matrix B 1 A. However, if B has a high condition number, we should use algorithms such as QZ and QR to triangularize the matrices A and B and then compute the eigenvalues without explicitly inverting B. Matrix Polynomials Each element f i,j (z n ) of the resultant matrix in (3.31) is a polynomial of the suppressed variable z n. Let d be the maximum degree of f i,j (z n ). For convenience, we rename λ = z n. The resultant can be written in matrix polynomial form as C(λ) = C 0 + C 1 λ + C 2 λ C d λ d, (3.41) where C 0, C 1,, C d are m m numeric matrices. The goal is to compute the solutions to C(λ) = 0. 69

93 Computing Resultant Using Eigenvalue Technique The following theorem converts the problem of solving matrix polynomial to the generalized eigenvalue problem. Theorem 3.2 Given a matrix polynomial C(λ) = d i=0 C iλ i, the roots of its corresponding determinant C(λ) = 0 are the finite eigenvalues of its companion polynomial A given by 0 I m I m 0 A =...., (3.42) I m C 1 d C 0 C 1 d C 1 C 1 d C 2 C 1 d C d 1 where C d is assumed to be nonsingular. And if C d is singular, the roots of C(λ) = 0 are the finite eigenvalues of the generalized system A 1 λ A 2 = 0, where A 1 and A 2 are given by I m I m I m I m 0 A 1 =...., A 2 =...., (3.43) 0 0 I m I m C d C 0 C 1 C 2 C d 1 where I m is the m m identity matrix and 0 is an m m matrix of zeros. See Manocha and Krishnan (1996) [38] for a proof to this theorem. 70

94 3.5 Resultant Solution to a Class of Quasi-Bilinear Polynomial Systems In this section, we apply resultant method to solve a class of quadratic polynomial systems which are linear with respect to part of variables. We termed them quasibilinear polynomial systems. These polynomial systems arise in our CS and RPS serial chain synthesis problems to be presented in Chapter A Quasi-Bilinear Polynomial System A system of n quasi-bilinear polynomial equation have a GLP structure as follows p i (x,y) 1, x 1, x 2,...,x l 1, x 1, x 2,...,x l, y 1, y 2,..., y m i = 1,...,n, (3.44) which are quadratic in x = (x 1, x 2,...,x l ) and linear in y = (y 1, y 2,...,y m ). And we require n = l + m to have a well-defined system. The root counting technique presented in the Chapter 3 allows us obtain a bound on the number of solutions to the system (3.44). We take one of the two sets from each equation to form a linear system. However we cannot have more than l sets 1, x 1, x 2,...,x l because a singular linear system will be resulted. Thus the generalized linear product (GLP) Bezout number can be calculated as B GLP (n, l) = l i=0 ( ) n. (3.45) i Our resultant solution in the following shows that this bound is exact. 71

95 3.5.2 Resultant Solution for the Case n = 5, l = 3, m = 2 To demonstrate a sparse resultant solution to the general case of the system (3.44), we consider the case of n = 5 with l = 3 quadratic variables and m = 2 linear variables, that is p i (x,y) 1, x 1, x 2, x 3 1, x 1, x 2, x 3, y 1, y 2 i = 1,..., 5. (3.46) Resultant Elimination Steps The following steps have been established to construct a resultant formulation. Step 1. Consider the parameters (x 1, x 2, x 3 ), we form the list of monomials up to degree µ = 4 of these parameters to be our multiplier list G i = 1, x 1, x 2, x 3 4 = {1, x 1, x 2, x 3,...,x 4 1, x3 1 x 2, x 3 1 x 3,...x 4 3 i = 1,..., 5, (3.47) which has M = ( ) ( l+µ l = 3+4 ) 3 = 35 entries. See the following section Discovering the Formulation for how G i are determined. Step 2. Multiply each p i with G i to to define Mn = 175 polynomials q j q j (z) : G 1 p 1 j = 1,..., 35 q j (z) : G 2 p 2 j = 36,..., 70 Q(z) :, (3.48).. q j (z) : G 5 p 5 j = 141,..., 175 which have the GLP structure q j 1, x 1, x 2, x 3 4 ( 1, x 1, x 2, x 3 1, x 1, x 2, x 3, y 1, y 2 ) = y 1, y 2 1, x 1, x 2, x , x 1, x 2, x 3 6 j = 1,...,175. (3.49) 72

96 The number of monomials contained in q j is computed to be ( ) ( ) ( ) ( ) µ l µ l N = m + = 2 + = 196. (3.50) l l 3 3 Step 3. Let w be the vector formed by the 196 monomials above, so the equations q j can be rewritten as Aw = 0, where A is the , numeric matrix of coefficients. Row reduce A by Gaussian elimination to identify r=rank[a] = 170 independent equations Bw = 0, (3.51) where B is an matrix with full row rank. Step 4. Now select one of the parameters in (y 1, y 2 ), denoted by λ, to be the suppressed variable. The monomials w are not fully independent. As a matter of fact, the following identities must be satisfied R k : z 2 λz 1 = 0, k = 1,...,L, (3.52) where z 1 1, x 1, x 2, x 3 5, and z 2 (λ) 1, x 1, x 2, x 3 5 There are L = ( µ+1+l l ) ( = ) = 56 of these identities. 3 Step 5. Form N r = 26 of the identities (3.52) into the equation [λc D]w = 0, where both C and D have entries that are simply 0 or 1, and assemble the

97 matrix equation, E(λ)w = B 0 w = λc D 0. (3.53) The set of these 26 identities have to be found such that E(λ) has full rank for arbitrary values of λ. The matrix E(λ) is the resultant that we are seeking. Reduction of the Eigenvalue Problem Once we have obtained the resultant matrix E(λ), we can use the eigenvalue technique discussed in Section to obtain the solutions of the suppressed variable λ. By exploiting the fact that only the last 26 rows of E(λ) have λ, we could further reduce this problem to a eigenvalue problem as follows. Step 1. Re-order the monomials in w and the identity equations (the last 26 rows of E(λ)) and re-write equation (3.53) in block matrix form as w ˆB 1 1 ˆB2 ˆB3 ˆB4 w I 1 λ + C 1 C = 0, (3.54) w 0 I 2 λ I where I 1, I 2 are identity matrices. In some cases, the last block-wise column is not present, but if it is, it must be full column rank. w 4 Step 2. Row reduce ˆB 4 to upper triangular form and yield B 11 B12 B13 U w 1 B 21 B22 B23 0 w 2 = 0, (3.55) I 1 λ + C 1 C w 3 0 I 2 λ I w 4

98 where matrix U is upper triangular. Step 3. Pre-multiply (3.55) by the matrix 0 0 I 1 0, 0 I 2 0 B23 to obtain I 1λ + C 1 C 2 B 21 B22 + B 23 λ w 1 = 0, (3.56) where the trailing blocks have been dropped, since they are zero. This is the square generalized eigenvalue problem we seek. The only computation involved in this process is the triangularization of ˆB 4, which can be done efficiently by sparse routines. w 2 Solutions of Other Variables For each eigenvalue of equation (3.56), we compute the associated eigenvector (w 1,w 2 ) from which we can obtain the solutions to other variables. However, in some cases, it may generate extraneous roots. In particular, the monomial list w may contain the monomial 1 and the solution of the eigenvalue problem can yield an eigenvector that has a zero for that entry; this is a solution infinity. To eliminate extraneous roots, one can substitute them back to verify if the original equations vanish. Discovering the Formulation The multiplier list G i in (3.47) is discovered by starting with µ = 0 and working up until the resultant matrix E(λ) (3.53) has full rank for a random choice of λ. 75

99 In carrying out this procedure, it is convenient to generate all L of the identities associated with a specific eigenvariable and degree µ, and then simply check whether the system has full column rank. Once this is satisfied, one can use linear algebra to find a subset of N r identities that maintain full rank. For our polynomial system (3.46), the results as we begin with µ = 0 and increment µ are summarized in the following table. µ N Mm r N r L rank(e) = N done. For µ 2, there are not enough identities to achieve full rank, because L < N r. On the other hand, while there seem to be plenty of identities for µ = 3, the rank test fails. Thus, µ = 4 is the first successful elimination procedure in the sequence. The reason that µ = 3 fails to result in a successful elimination can be found in the structure of the design equations which can be written in the form p i = α i + β i y 2, i = 1,...,5. (3.57) Note that α i is of the form 1, x 1, x 2, x 3 1, x 1, x 2, x 3, y 1 and β i is of the form 1, x 1, x 2, x 3. Now, for any three l, m, n {1, 2, 3, 4, 5, we must have the identity α l β l p l D lmn = det α m β m p m = 0, (3.58) α n β n p n 76

100 because the last column is a linear combination of the first two. All terms of this determinant take the form 1, x 1, x 2, x 3 3 p i or y 1 1, x 1, x 2, x 3 2 p i, which means that each D lmn is a linear combination of the 100 equations and 35 identities. There are ( 5 3) = 10 such relations, all independent, so the matrix for the expanded system has row-rank of only = 125: the system is not full rank. The case µ = 4 is interesting because r = 170 < Mn = 175. The reason for this can again be seen in the structure of the design equations, now written in the form p i = α i + β i y 1 + γ i y 2, (3.59) where α i is of the form 1, x 1, x 2, x 3 2 and β i, γ i are both of the form 1, x 1, x 2, x 3. We now form the five identities D i = det[α j β j γ j p j, j i = 1,..., 5] = 0, i = 1,..., 5. (3.60) The terms in these determinants are all of the form 1, x 1, x 2, x 3 4 p i, which are linear combinations of the expanded set of equations. Thus, the rank of the expanded set of equations is = Generalization This resultant elimination solution has been generalized a series of quasi-bilinear polynomial systems with 2 n 7, 1 l 3 and 1 m 4. These systems arise in our synthesis equations in Chapter 5. For each case, we follow the same resultant elimination steps and apply general eigenvalue technique to obtain all roots. The 77

101 Case n l m G i = 1, x 1,...,x l µ Mn λ [B] N r , x 1, x 2, x y , x 1, x 2, x y , x 1, x y , x 1, x 2, x y , x 1, x y x , x 1, x 2, x y , x 1, x y , x 1, x 2, x x , x 1, x y x , x 1, x 2 6 x x y Table 3.1: Resultant formulations for a class of quasi-bilinear polynomial systems. Note N r gives the root count which has been predicted by the GLP Bezout number B GLP (n, l) = l ( n ) i=0 i. results are summarized in Table 3.1. Note that the last column N r is actual root count which has been predicted by the GLP bound defined in (3.45). While this resultant elimination procedure is general, there are three related aspects that must be adapted to a given set of polynomials: (i) the selection of monomials in Step 1, (ii) the choice of the suppressed variable λ in Step 4, and (iii) the selection of the identities in Step 5. The rank of E(λ) tests whether a particular 78

102 choice of monomials and identities is satisfactory. However, once this is done, the formulation is valid for any general member of the family of polynomials systems related to p i, i = 1,...,n. 3.6 Summary In this chapter, we have studied polynomial homotopy and resultant elimination methods for solving polynomial systems. We first presented the fundamental theory on the homotopy method, followed by four linear product bases start systems. Since our synthesis equations have a natural GLP structure, we present a new parallel homotopy solver POLSYS GLP based on GLP start system. We then described the basic resultant elimination steps, methods for constructing and computing resultant matrices, and at last, an application to a class of quasi-bilinear polynomial systems that arise in our synthesis problems. 79

103 Chapter 4 Serial Chain Constraint Equations 4.1 Overview In this chapter, we formulate and solve the constraint equations for a class of five degree-of-freedom serial chains with spherical wrists. The first two joints constrain the center of the spherical joint to lie on a surface, called the reachable surface. There are four general surfaces associated with four serial chains PP, RP, PR and RR, and three special cases defined by special dimensions relating the two joints. In each of the seven cases, we formulate the constraint equations as a polynomial system, determine its general linear product structure in order to obtain a bound on the number of roots, and solve the constraint equations either algebraically or using polynomial homotopy to determine the actual number of roots. For some cases, multiple processors are necessary. We begin by considering the constraint equations for the planar RR chain known as the Burmester problem. Our synthesis problem is often termed the spatial 80

104 T 3 T 4 P 4 P 3 T 2 P 5 T 5 P 2 B P 1 T 1 Figure 4.1: Burmester problem: five position synthesis of planar RR chain. Burmester problem. 4.2 Burmester Problem The synthesis problem for planar RR chains originates with the determination by Burmester (1886) [4] of those points in a body that lie on a circle for a given set planar positions. He showed that given five planar positions there were as many as four pairs of points, the so-called Burmester points, that define RR chains that can reach these positions (Figure 4.1). Algebraically, the Burmester problem can be viewed as solving the polynomial system arising from the constraint that the moving pivot lie on a circle around the fixed pivot. 81

105 Circle Equation The planar RR chain has the property that the moving pivot P = (X, Y ) T lies on the circle centered at the fixed pivot B = (b 1, b 2 ) T. That is, P and B satisfy the following equation: (B P) 2 R 2 = 0, (4.1) which consists of five parameters b 1, b 2, X, Y, R. Design Equation Since the circle equation (4.1) has five parameters, we can specify up to five task positions to have a well defined design problem. Let these five task positions denoted by the 4 4 homogeneous matrices [T i ] = [A i,d i ](i = 1,...,5), where A i and d i represent the rotation and translation. Let p = (p 1, p 2 ) T be the coordinate vector of the wrist in the moving frame. The coordinates of the moving pivot in each of the task locations can be computed as P i = [T i ]p. Our design task requires that these points P i lie on the circle centered at B of radius R. This yields the polynomial system (B P i ) 2 R 2 = 0, i = 1,..., 5. (4.2) Subtracting the first of these equations from the remaining to eliminate R yields our design equations for planar RR chain: (P 2 P 2 P 1 P 1 ) 2B (P 2 P 1 ) (P 3 P 2 P 1 P 1 ) 2B (P 3 P 1 ) B(z) = = 0. (4.3) (P 4 P 2 P 1 P 1 ) 2B (P 4 P 1 ) (P 5 P 5 P 1 P 1 ) 2B (P 5 P 1 ) 82

106 This is a set of four quadratic equations in the four unknowns z = (p 1, p 2, b 1, b 2 ). The total degree of this system is 2 4 = 16. The GLP Bound Now we provide a bound on the root count to the design equation (4.3). Notice that the term (P i P i P 1 P 1 ) are actually linear with respect to p 1 and p 2 because the square terms are cancelled. Thus the system (4.3) has a GLP structure as follows, b 1, b 2, 1 p 1, p b 1, b 2, 1 p 1, p B(z). (4.4) b 1, b 2, 1 p 1, p b 1, b 2, 1 p 1, p This structure is often called bilinear. To calculate the GLP bound on the root count, we take a linear factor from each equation to form a system of four linear equations. Since each GLP structure has two factors, there are total 2 4 = 16 possibilities. However we must have two sets of b 1, b 2, 1 and two sets of p 1, p 2, 1 to form a nonsingular linear system. This yields a GLP bound B GLP = ( 4 2) = 6. Resultant Solution This system of polynomials (4.3) is small enough that resultant elimination can be used to obtain a univariate polynomial, which is found to be of degree four. See McCarthy (2000) [41] for details. Also see Suh and Radcliffe (1978) [65], Erdman and Sandor (1997) [14]. Thus, there may be as many as four points in the moving body that lie on a circle for five specified positions of the end- 83

107 effector. Once the point B and point p are defined, then it is possible to determine a planar RR chain that guides this point through the specified positions. 4.3 Spatial Burmester Problem Chen and Roth (1969) [6] generalized Burmester problem by seeking points and lines in a moving body that take positions on surfaces associated with articulated serial chains, in order to design robot manipulators. We call this problem spatial Burmester problem. A subset of these serial chains consists of two joints (R or P) that support a spherical wrist (S). The combinations available for revolute and prismatic joints yields four basic chains: PPS, RPS, PRS, and RRS. We also consider some special cases which are more practical, of these four chains. As seen in the Table 2.1, revolute and prismatic joints can be combined to define other specialized joints. In particular, the sequence of two revolute joints that have axes that intersect at right angles is called a gimbal, or universal joint, denoted by a T. We denote this case by TS chain. Similarly, we treat the RPS or PRS chain whose axes of R-joint and P-joint are parallel, as a CS chain. Finally the RRS chain whose two R-joint axes are perpendicular is called right RRS. The trajectory of the spherical wrist of these seven chains is a surface in space, termed reachable surfaces. These reachable surfaces are plane(pps), sphere(ts), hyperboloid(rps), elliptic cylinder(prs) cylinder(cs), circular torus(right RRS) and torus(rrs). See Table 4.1. Note if the R-joint and P-joint axes are perpendicular in 84

108 Case Chain angle length Surface 1 PPS - - plane 2 TS π/2 0 sphere 3 CS 0 - circular cylinder 4 RPS α - circular hyperboloid 5 PRS α - elliptic cylinder 6 right RRS π/2 ρ circular torus 7 RRS α ρ general torus Table 4.1: The basic serial chains and their associated reachable surfaces. a RPS or PRS chain, the reachable surface degenerates to a plane. Similarly if the two R-joint axes in a RRS chain are parallel, the reachable surface is also a plane. Synthesis of these cases are equivalent to that of PPS chains. All PP chains are essentially the same as long as the directions of the two joints are not parallel, so that some component of movement perpendicular to the first prismatic joint is available by sliding along the second joint. Because the spherical wrist allows all orientation of the end-effector, the synthesis problems we consider are equivalent to seeking points on the end-effector that lie on these reachable surfaces. For each of the cases in Table 4.1, we derive the surface equation and formulate the design equations by requiring these points P i lie on the reachable surfaces. We then provide a GLP bound on the root count. If this bound is small, we provide a resultant solution. Otherwise we solve the design equation using our homotopy solver POLSYS GLP. For some cases, multiple processors are 85

109 necessary to solve these equations. This is done by running POLSYS GLP on Blue Horizon of San Diego Super Computer Center. In what follows, we let matrices [T i ] = [A i,d i ], i = 1,..., n denote the n given spatial displacements which the end-effector must reach, [A i ] is a 3 3 rotation matrix and d i is a 3 1 translation vector. And let p = (p 1, p 2, p 3 ) T be the position vector of the spherical wrist with respect to the moving frame. The position of the spherical wrist in the fixed frame can be computed as P i = [T i ]p = [A i ]p +d i. These points have the feature that the difference of the magnitude of two points is linear with respect to the variables p 1, p 2, p 3. That is, P i P i P j P j = ([A i ]p + d i ) ([A i ]p + d i ) ([A j ]p + d j ) ([A j ]p + d j ) = (p T [A i ] T [A i ]p + 2d T i [A i]p + d i d i ) (p T [A j ] T [A j ]p + 2d T j [A j]p + d j d j ) = (p p + 2d T i [A i]p + d i d i ) (p p + 2d T j [A j]p + d j d j ) = 2(d T i [A i] d T j [A j])p + d i d i d j d j, (4.5) which is linear with respect to p 1, p 2, p The Plane Plane Equation The PPS serial chain has the feature that the wrist center P is constrained to lie on a plane (Figure 4.2). That is, P must satisfy the plane equation G P d = 0, (4.6) 86

110 P G Figure 4.2: A plane as traced by a point at the wrist center of a PPS serial chain. where G = (g 1, g 2, g 3 ) is the directional vector normal the plane and d is the product of the magnitude G and the signed normal distance to the plane. The plane equation consists of six independent parameters two coordinates of G, three coordinates of P, and the scalar d. Notice the components of G are not independent because the plane depends on the direction of G, not its magnitude. Design Equation Since the plane equation (4.6) has six independent parameters, we can specify up to n = 6 task positions to determine a PPS chain. Substituting the point P i (i = 1,...,6) to the plane equation (4.6) yields the polynomial system G P i d = 0, i = 1,...,6. (4.7) Recall P i = [A i ]p + d i where [A i,d i ] are the task positions and p = (p 1, p 2, p 3 ) T is position vector of the spherical joint in the task position frame. Subtract the first of these equations from the remaining to eliminate the variable d. To constrain the magnitude of G, we choose a vector m and scalar e, and require 87

111 that m G = e. This yields the design equations for PPS chains G (P 2 P 1 ). P(z) = = 0. (4.8) G (P 6 P 1 ) m G e This is a set of five quadratic equations and one linear equation in the six unknowns z = (g 1, g 2, g 3, p 1, p 2, p 3 ). The total degree of this system is 2 5 = 32. The GLP Bound It is easy to see that this polynomial system (4.8) has the GLP structure g 1, g 2, g 3 p 1, p 2, p 3, 1 1. P(z), (4.9) g 1, g 2, g 3 p 1, p 2, p 3, 1 5 g 1, g 2, g 3, 1 which yields a Bezout GLP bound B GLP = ( 5 2) = 10. Resultant Solution This GLP bound is small enough that direct elimination of the parameters can be used to obtain a univariate polynomial, which is found to be of degree 10. Thus, there may be as many as 10 points in the moving body that lie on a plane for six specified positions of the end-effector. Once the plane and point p are defined, then it is possible to determine a PPS chain, a parallel RRS or a right RPS chain that guides this point through the specified n = 6 task positions. 88

112 Figure 4.3: A sphere traced by a point at the wrist center of a TS serial chain. 4.5 The Sphere Sphere Equation We now consider the TS serial chain. The spherical center P is constrained to lie on a sphere of radius R around the T-joint center B = (b 1, b 2, b 3 ) T, Figure 4.3. This means the point P satisfy the equation (P B) 2 R 2 = 0, (4.10) which consist of seven parameters three for each of P,B and one for R. Design Equation Evaluating seven points P i (i = 1,..., 7) on the sphere equation (4.10) yields (P i B) 2 R 2 = 0, i = 1,..., 7. (4.11) 89

113 Subtract the first equation from the remainder in order to eliminate R, and obtain the design equations S(z) for the TS chain, given by (P 2 P 2 P 1 P 1 ) 2B (P 2 P 1 ) S(z) =. = 0, (4.12) (P 7 P 7 P 1 P 1 ) 2B (P 7 P 1 ) where z = (p 1, p 2, p 3, b 1, b 2, b 3 ) T are the unknowns. The GLP Bound Because (P i P i P 1 P 1 ) are linear with respect to p, system (4.12) has the GLP structure as follows, p 1, p 2, p 3, 1 b 1, b 2, b 3, 1 1 S(z)., (4.13) p 1, p 2, p 3, 1 b 1, b 2, b 3, 1 6 from which we can compute the bound B GLP = ( 6 3) = 20. Resultant Solution Liao and McCarthy (2001) [35] provided a resultant elimination solution which yields a univariate polynomial of degree 20. Innocenti (1994) [23] presents an example that results in 20 real roots. Thus, given seven arbitrary spatial positions there can be as many as 20 points in the moving body that have positions lying on a sphere. For each real point, it is possible to determine an associated TS chain. 4.6 The Elliptic Cylinder Elliptic Cylinder Equation The reachable surface of a PRS chain is an elliptic cylinder (Figure 4.4). It is generated by a circle that has its center swept along a line 90

114 Figure 4.4: The elliptic cylinder reachable by a PRS serial chain. L(t) = B + ts 1 such that the vector through the center normal to the plane of the circle maintains a constant direction S 2 at an angle α relative to the direction S 1 of L(t). The major axis of the elliptic cross section is the radius R of the circle and the minor axis is R cos α. Consider a general point on the cylinder P, and let Q be the center of the circle. The point Q moves along the axis L(t) which has the Plucker coordinates S 1 = (S 1,B S 1 ). The distance from the reference point B to Q is denoted by d. These definitions allow us to express the location of P relative to B as P B = ds 1 + Ru, (4.14) where u is an unit vector in the direction S 1 S 2. Compute the cross product with S 1 to eliminate d, and the cross product with S 2 to obtain S 2 ((P B) S 1 ) = R(S 2 S 1 )u. (4.15) 91

115 The magnitude of this vector identity yields our equation of the elliptic cylinder ( S2 ( (P B) S 1 )) 2 R 2 (S 1 S 2 ) 2 = 0. (4.16) This equation has 13 dimensional parameters: the radius R, three each for the directions S 1, S 2, and the points P and B. However only 10 of them are independent because magnitude of the directions S 1 and S 2 can be set arbitrarily, and the point B can be any point on the line S 1. Equation (4.16) is of degree six. However this degree can be reduced by expanding the triple cross product and introducing new variables, that is S 2 ((P B) S 1 ) =(S 1 S 2 )(P B) ((P B) S 2 )S 1 =(S 1 S 2 )(P (P K)S 1 + Q), (4.17) where which are subjected to the constraints K = S 2 S 1 S 2, and Q = (B K)S 1 B. (4.18) S 1 S 1 = 1, K S 1 = 1, and Q K = 0. (4.19) These definitions reduce the degree of the polynomial (4.16) from six to four, so we have (P (P K)S 1 + Q) 2 R 2 = 0, (4.20) where we have used the constraints (4.19) and canceled the term (S 1 S 2 ) 2. 92

116 Equation (4.20) again consists of 13 parameters R, S 1 = (g 1, g 2, g 3 ), K = (k 1, k 2, k 3 ), and Q = (q 1, q 2, q 3 ). Only 10 of them are independent because of the three constraints (4.19). Design Equation Evaluating (4.19) on ten points P i (i = 1,...,10) yields (P i (P i K)S 1 + Q) 2 R 2 = 0, i = 1,..., 10. (4.21) Subtract the first of these equations from the remaining to eliminate R and obtain (P j+1 (P j+1 K)S 1 + Q) 2 (P 1 (P 1 K)S 1 + Q) 2 = 0, j = 1,...,9. (4.22) The design equation for elliptic cylinder is formed by equation (4.22) together with the constraints (4.19), written as (P 2 (P 2 K)S 1 + Q) 2 (P 1 (P 1 K)S 1 + Q) 2. (P 10 (P 10 K)S 1 + Q) 2 (P 1 (P 1 K)S 1 + Q) 2 E(z) = = 0, (4.23) S 1 S 1 1 K S 1 1 Q K where z = (g 1, g 2, g 3, k 1, k 2, k 3, p 1, p 2, p 3, q 1, q 2, q 3 ) T are the twelve unknowns. The total degree of the system is = 2, 097,

117 The GLP Bound Recall that the quadratic terms in P j+1 P j+1 P 1 P 1 cancel, as does the term Q 2. Thus, the polynomial (4.22) has the monomial structure p 1, p 2,p 3, 1 p 1, p 2, p 3, 1 2 k 1, k 2, k 3 2 p 1, p 2, p 3, 1 2 k 1, k 2, k 3 g 1, g 2, g 3 p 1, p 2, p 3, 1 q 1, q 2, q 3 p 1, p 2, p 3, 1 k 1, k 2, k 3 g 1, g 2, g 3 q 1, q 2, q 3. (4.24) This leads to the GLP structure of (4.23) given by p 1, p 2, p 3, 1 p 1, p 2, p 3, q 1, q 2, q 3, 1 k 1, k 2, k 3, 1 k 1, k 2, k 3, g 1, g 2, g 3, 1 1. p 1, p 2, p 3, 1 p 1, p 2, p 3, q 1, q 2, q 3, 1 k 1, k 2, k 3, 1 k 1, k 2, k 3, g 1, g 2, g 3, 1 9 E(z). g 1, g 2, g 3, 1 2 k 1, k 2, k 3, 1 g 1, g 2, g 3, 1 k 1, k 2, k 3, 1 q 1, q 2, q 3, 1 (4.25) Our POLSYS GLP obtain the bound for this system B GLP = 247, 968, which is large. Homotopy Solution This system was solved using our parallel version of POL- SYS GLP on 128 nodes of the Blue Horizon supercomputer at the San Diego Supercomputer Center. The result was 18,120 solutions in almost 33 minutes. Because each node of Blue Horizon has eight processors, this corresponds to 563 cpu hours, or approximately 440 paths/processor-hour. Thus, given ten arbitrary spatial positions there can be as many as 18,120 points in the moving body that have positions lying on an elliptical cylinder. For each real point, it is possible to determine an associated PRS chain. 94

118 Figure 4.5: The circular cylinder reachable by a CS serial chain. 4.7 The Circular Cylinder Circular Cylinder Equation If we require the axis of the prismatic joint to be parallel to that of the revolute joint, that is S 1 = S 2 = G, the ellipse cylinder becomes a circular cylinder (Figure 4.5). Therefore the constraint equation (4.16) degenerates to that of a circular cylinder, defined by ((P B) G) 2 = R 2 G 2, (4.26) where we have used the fact that (v G) 2 = v 2 G 2 if v G and canceled G 2 on both sides. Notice that we allow G to have an arbitrary magnitude. Equation (4.26) has 10 parameters, the radius R and three each in the vectors P = (X, Y, Z), B = (b 1, b 2, b 3 ) and G = (g 1, g 2, g 3 ). However, because only the direction of G is important to the definition of the cylinder, its three components 95

119 are not independent. The components of the point B are also not independent, but for a different reason. It is because any point on the line L(t) can be selected as the reference point B. Therefore the circular cylinder equation (4.26) has eight independent parameters. Design Equation Thus, a cylindric PRS chain can be designed to reach at most eight spatial positions. To obtain the design equation for CS chain, we evaluate the circular cylinder equation on eight task positions, that is, substitute P i (i = 1,..., 8) to (4.26). The result is ((P i B) G) 2 R 2 G 2 = 0, i = 1,...,8. (4.27) Subtract the first equation from the remaining seven to eliminate R and obtain ((P j+1 B) G) 2 ((P 1 B) G) 2 = 0, j = 1,...,7. (4.28) To constrain the magnitude of G we choose an arbitrary vector m and scalar e and require the components of G satisfy the constraint, G m e = 0. (4.29) To constrain the point B we require B to lie on a specific plane U : (n, f), that is B n f = 0, (4.30) where n and f are chosen arbitrarily to avoid the possibility that the line L(t) may lie entirely on U. 96

120 System (4.28) can be simplified and assembled with the two constraint equations to define the design equation for CS serial chain: (P 2 G) 2 (P 1 G) 2 2((P 2 P 1 ) G) (B G). C(z) = (P 8 G) 2 (P 1 G) 2 2((P 8 P 1 ) G) (B G) = 0, (4.31) G m e B n f where z = (b 1, b 2, b 3, g 1, g 2, g 3, p 1, p 2, p 3 ) T are the nine unknowns. This is a set of seven polynomials of degree four and two of degree one. The total degree is 4 7 = 16, 384. The GLP Bound We now consider the monomial structure of polynomial system (4.31). The first seven quartic polynomials all have a linear combination of monomials in the set generated by ( p 1, p 2, p 3, 1 g 1, g 2, g 3 ) 2 p 1, p 2, p 3, 1 g 1, g 2, g 3 b 1, b 2, b 3 g 1, g 2, g 3. (4.32) This can be manipulated to show the system of polynomials (4.31) is a special case of the GLP structure, g 1, g 2, g 3 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, b 2, b 3, 1 1. C(z) g 1, g 2, g 3 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, b 2, b 3, 1 7 = 0. (4.33) b 1, b 2, b 3, 1 g 1, g 2, g 3, 1 In order to determine the number of roots, we notice that the components of G = (g 1, g 2, g 3 ) are determined by its linear constraint combined with two terms 97

121 taken from g 1, g 2, g 3 in the seven polynomials. Furthermore, because this term is squared, the number of choices is increased by a factor of 2 2 = 4. Next we choose from zero to three of the terms p 1, p 2, p 3, 1 from the remaining five polynomials to define p = (p 1, p 2, p 3 ). The remaining factors and the last linear equation define the parameters B = (b 1, b 2, b 3 ). This yields the bound of B GLP = 2 2 ( 7 2 ) 3 i=0 which is significantly less than the total degree. ( ) 5 = 2, 184, (4.34) i Homotopy Solution We used our homotopy solver POLSYS GLP to determine the roots of polynomials (4.31) for a random set of test cases. By tracking 2,184 homotopy path, we found that there may be as many as 804 points in the moving body that have positions lying on a circular cylinder. For each of these points, we can determine an associated CS chain. The computation is done in 2 hrs on a 1.5 GHz Pentium 4 system. 4.8 The Circular Hyperboloid Circular Hyperboloid Equation A circular hyperboloid is generated by rotating one line around another so that every point on the moving line traces a circle around the fixed line, G, which is the axis of the hyperboloid (Figure 4.6). Of all of these circles there is one with the smallest radius, R, and its center B = (b 1, b 2, b 3 ) is the center of the hyperboloid. Let G = (g 1, g 2, g 3 ) be the direction of the axis L(t) = 98

122 Figure 4.6: The circular hyperboloid traced by the wrist center of an RPS serial chain. B + tg. The unit vector N perpendicular to G though B is the common normal between the axis G and one of the generated lines, H. The generator is located at the distance R along N, and lies at an angle α around N relative to the axis G. The distance d measured along the axis G from B to a point P on the generator is given by d = (P B) G G G. (4.35) Notice that we are not assuming that G is a unit vector. The magnitude of P B is now computed to be (P B) 2 = R 2 + d 2 + (d tanα) 2. (4.36) Substitute d into this equation to obtain the equation of a circular hyperboloid (P B) 2 ((P B) G) 2( 1 + tan 2 α) R 2 = 0. (4.37) G G 99

123 When α = 0, this becomes the equation of a cylinder presented in the previous section. Figure 4.6(a) shows the RPS chain associated with the circular hyperboloid. The R- joint axis is G, and its P-joint axis in the direction α measured around the common normal. The point P is the center of the S-joint, and lies at the distance R in the direction N of the common normal. Expand equation (4.37) and collect terms to obtain k 0 P P + 2K P (P G) 2 ζ = 0, (4.38) where we have introduce the parameters k 0, K = (k 1, k 2, k 3 ) and ζ defined by k 0 = G G 1 + tan 2 α, K = (B G)G k 0B, ζ = (B G) 2 k 0 B B + k 0 R 2. (4.39) Given values for ζ, k 0, K, and G, we can compute B by solving the linear equations k 1 g 1 2 k 0 g 1 g 2 g 1 g 3 b 1 k 2 = g 1 g 2 g2 2 k 0 g 1 g 3 b 2. (4.40) k 3 g 1 g 3 g 2 g 3 g3 2 k 0 b 3 Then the length and twist parameters, R and α, are obtained from the formulas α = arccos ( k 0 ) ζ (B G) 2 + k 0 B B, R =. (4.41) G G k 0 Thus, the 11 dimensional parameters ζ, k 0, K, G, and P define a circular hyperboloid. However only 10 of them are independent because it is the direction not the magnitude of G that matters. Design Equation Thus, a RPS serial chain can be designed to reach up to ten arbitrary task position. Evaluating the circular hyperboloid equation (4.38) on the 100

124 displaced positions P i (i = 1,..., 10) yields the polynomial system k 0 P i P i + 2K P i (P i G) 2 ζ = 0, i = 1,..., 10. (4.42) Subtract the first of these equations from the remaining in order to eliminate ζ and obtain k 0 (P j+1 P j+1 P 1 P 1 )+2K (P j+1 P 1 ) (P j+1 G) 2 +(P 1 G) 2 = 0, j = 1,...,9. (4.43) As we have seen previously, the magnitude of G can be set using an arbitrary vector m and scalar e in the constraint equation, G m e = 0. (4.44) The result is that the circular hyperboloid is defined by the system of polynomial equations k 0 (P 2 P 2 P 1 P 1 ) + 2K (P 2 P 1 ) (P 2 G) 2 + (P 1 G) 2. H(z) = = 0, k 0 (P 10 P 10 P 1 P 1 ) + 2K (P 10 P 1 ) (P 10 G) 2 + (P 1 G) 2 G m e (4.45) where z = (k 0, k 1, k 2, k 3, p 1, p 2, p 3, g 1, g 2, g 3 ) T are the ten unknowns. This is a system of nine fourth degree polynomials and one linear equation which has a total degree of 4 9 = 262, 144. The GLP Bound However GLP structure gives a better bound on the number of solutions. Recall in (4.5) that the term P j+1 P j+1 P 1 P 1 are linear with respect 101

125 to p 1, p 2, and p 3. This means the polynomials (4.43) have the monomial structure k 0 p 1, p 2, p 3, 1 k 1, k 2, k 3 p 1, p 2, p 3, 1 ( p 1, p 2, p 3, 1 a, b, c ) 2. (4.46) This simplifies to yield the GLP structure for the system (4.45) as g 1, g 2, g 3 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, k 3, 1 1. H(z). (4.47) g 1, g 2, g 3 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, k 3, 1 9 g 1, g 2, g 3, 1 which yields a bound of B GLP = 2 2 ( 9 2 ) 3 i=0 ( ) 7 = 9, 216. (4.48) i Homotopy Solution The parallel version of POLSYS GLP was run on 8 64-bit AMD Opetron processors of UCI s Beowulf cluster, and required 30 minutes to track 9216 homotopy paths, that is 2304 paths/processor-hour. This particular problem has a structure that is convenient for polyhedral homotopy algorithms, which yield the same solutions in minutes on a single processor by tracking only 1024 paths, see Gao and Li (2003) [16]. Thus, for ten spatial positions, we can find as many as 1024 points that have all 10 positions on a circular hyperboloid. For each of these points we can find an associated RPS chain. 4.9 The Circular Torus Circular Torus Equation A circular torus is generated by sweeping a circle around an axis so its center traces a second circle. Let the axis be L(t) = B + tg, 102

126 Figure 4.7: The circular torus traced by the wrist center of a right RRS serial chain. with Plucker coordinates G = (G, B G), Figure 4.7. Introduce a unit vector v perpendicular to this axis so the center of the generating circle is given by Q B = ρv. Then a point P on the torus is defined by the vector equation, P B = ρv + R(cosφv + sin φg), (4.49) where φ is the angle measured from v to the radius vector of the generating circle. An algebraic equation of the torus is obtained from (4.49) by first computing the magnitude (P B) 2 = ρ 2 + R 2 + 2ρR cos φ. (4.50) Next compute the dot product with G, to obtain (P B) G = R sin φ. (4.51) Finally, eliminate cosφ and sin φ from these equations, and the result is G 2 ((P B) 2 ρ 2 R 2 ) 2 + 4ρ 2 ((P B) G) 2 4ρ 2 G 2 R 2 = 0. (4.52) 103

127 This is the equation of a circular torus. It has 10 independent parameters, the scalars ρ and R, and the three vectors G, P and B. Note G has only two independent parameters and B has three because it is the center of the torus therefore fully constrained. In order to simplify equation (4.52), we introduce the parameters H = 2ρG and k = B 2 ρ 2 R 2, (4.53) which yields the identity 4ρ 2 R 2 = H 2 (B 2 H2 4 k). (4.54) These definitions allows us rewrite the circular torus equation (4.52) into (P P 2P B + k) 2 + ((P B) H) 2 H 2 (B 2 H2 4 k) = 0, (4.55) which again has 10 independent parameters P,B = (b 1, b 2, b 3 ),H = (h 1, h 2, h 3 ) and k. Design Equation Thus, the synthesis of right RRS chain allows specifying up to n = 10 task positions. Evaluating (4.55) on points P i (i = 1,..., 10) to obtain the design equation ((P 1 ) 2 2P 1 B + k) 2 + ((P 1 B) H) 2 H 2 (B 2 H2 k) 4 T(z) =. = 0, ((P 10 ) 2 2P 10 B + k) 2 + ((P 10 B) H) 2 H 2 (B 2 H2 k) 4 (4.56) 104

128 where z = (k, b 1, b 2, b 3, h 1, h 2, h 3, p 1, p 2, p 3 ) T are the ten unknowns. The total degree of the system is 4 10 = 1, 048, 576. The GLP Bound It is difficult to find a simplified formulation for these equations, even if we subtract the first equation from the remaining in order to cancel terms. Expanding the polynomials in the system (4.56) and examining each of the terms, we can identify the GLP structure p 1, p 2, p 3, h 1, h 2, h 3, 1 2 p 1, p 2, p 3, h 1, h 2, h 3, b 1, b 2, b 3, k, T(z).. (4.57) p 1, p 2, p 3, h 1, h 2, h 3, 1 2 p 1, p 2, p 3, h 1, h 2, h 3, b 1, b 2, b 3, k, This allows us to compute the bound on the number of roots as B GLP = j=0 ( ) 10 = 868, 352. (4.58) j Homotopy Solution Our parallel POLSYS GLP solver computed 94,622 solutions in 72 minutes on 128 nodes or 1024 processors of the Blue Horizon Supercomputer. This means the over 800,000 paths were tracked on 1024 processors at a rate of approximately 707 paths per CPU hour The General Torus General Torus Equation A general torus is defined by sweeping a circle that has a general orientation in space around an arbitrary axis, Figure 4.8. Let S 1 = (S 1,B S 1 ) be the Plucker coordinates of the line that forms the axis of the torus, and S 2 = (S 2,Q S 2 ) be the line through the center of the sweeping circle, perpendicular 105

129 Figure 4.8: The general torus reachable by the wrist center of an RRS serial chain. to its plane. These two lines define a common normal N and we choose its intersection with S 1 and S 2 to be the reference points B and Q, respectively. The normal angle and distance between these lines around and along their common normal are denoted α and ρ. Finally, we identify the center of the sweeping circle as lying a distance d along S 2 measured from Q. In this derivation, we constrain S 1 and S 2 to be unit vectors, in order to reduce the degree of the resulting equation. This allows us to define the unit vector in the common normal direction as n = (S 1 S 2 )/ sinα, so we obtain a general point P on the torus from the vector equation, P B = ρn + ds 2 + R(cosφn + sin φ(s 2 n)). (4.59) The algebraic equation for the torus is obtained by first computing (P B) 2 = ρ 2 + d 2 + R 2 + 2ρR cosφ, (4.60) and (P B) (S 2 n) = R sin φ. (4.61) 106

130 Notice that S 2 n is S 2 S 1 S 2 sin α = 1 sin α (S 1 cosαs 2 ). (4.62) Now, eliminate φ between these two equations to obtain ((P B) 2 ρ 2 d 2 R 2 ) 2 + 4ρ2 sin 2 α ((P B) S 1 d cosα) 2 4ρ 2 R 2 = 0. (4.63) This equation has four scalar parameters ρ, α, d and R, and three vector parameters P, B, and S 1 which combine with the constraint, S 1 = 1, to yield 12 independent parameters. In order to simplify the use of equation (4.63), we introduce the new parameters k 1 =B B ρ 2 R 2 d 2, k 2 =(B S 1 + d cosα) 2ρ sin α, k 3 =4ρ 2 R 2, This allow us to write (4.63) in the form H = 2ρ sin α S 1, (4.64) (P P 2P B + k 1 ) 2 + (P H k 2 ) 2 k 3 = 0. (4.65) This is a quartic polynomial in the 12 unknowns, consisting of k 1, k 2, k 3 and the components P, B = (b 1, b 2, b 3 ) T, and H = (h 1, h 2, h 3 ) T. Design Equation Thus, a general RRS serial chain can be designed to reach up to n = 12 task position. Substitute the points P i, (i = 1,..., 12) in to the torus 107

131 equation (4.65) and subtract the first of these equations from the remaining to cancel k 3 to obtain the design equation (P 2 P 2 2P 2 B + k 1 ) 2 (P 1 P 1 2P 1 B + k 1 ) 2 +(P 2 H k 2 ) 2 (P 1 H k 2 ) 2 G(z) =. = 0, (4.66) (P 12 P 12 2P 12 B + k 1 ) 2 (P 1 P 1 2P 1 B + k 1 ) 2 +(P 12 H k 2 ) 2 (P 1 H k 2 ) 2 where z = (b 1, b 2, b 3, h 1, h 2, h 3, k 1, k 2, p 1, p 2, p 3 ) T are the eleven unknowns. The total degree of this system of polynomials is 4 11 = 4, 194, 304. The GLP Structure We can refine the estimate of the number of roots of this polynomial system by using the linear product decomposition. Expanding these polynomials, we obtain the terms P 4 j+1 P4 1 p 1, p 2, p 3, 1 3, (2P j+1 B) 2 (2P 1 B) 2 p 1, p 2, p 3, 1 2 b 1, b 2, b 3 2, 4P 2 j+1 (P j+1 B) + 4P 2 1 (P 1 B) p 1, p 2, p 3, 1 3 b 1, b 2, b 3, 2k 1 (P 2 j+1 P2 1 2P j+1 B + 2P 1 B) p 1, p 2, p 3, 1 b 1, b 2, b 3, 1 k 1, (P j+1 H) 2 (P 1 H) 2 p 1, p 2, p 3, 1 2 h 1, h 2, h 3 2 2k 2 (P j+1 H P 1 H) p 1, p 2, p 3, 1 h 1, h 2, h 3 k 2 (4.67) 108

132 Case Reachable Surface n Total degree B GLP Number of roots 1 plane sphere circular cylinder 8 16,384 2, circular hyperboloid ,144 9,216 1,024 5 elliptic cylinder 10 2,097, ,968 18,120 6 circular torus 10 1,048, ,352 94,622 7 general torus 12 4,194, ,702 42,786 Table 4.2: Summary of the number of task positions, total degree, GLP bound, and number of solutions that define each reachable surface. Notice that the quartic terms in the first expression cancel. We combine these monomials into the linear product decomposition, p 1, p 2, p 3, 1 2 b 1, b 2, b 3, h 1, h 2, h 3, 1 p 1, p 2, p 3, b 1, b 2, b 3, h 1, h 2, h 3, k 1, k 2, 1 1, G(z).. p 1, p 2, p 3, 1 2 b 1, b 2, b 3, h 1, h 2, h 3, 1 p 1, p 2, p 3, b 1, b 2, b 3, h 1, h 2, h 3, k 1, k 2, 1 11, (4.68) This allows us to compute the bound of B GLP = 448, 702 obtained by POLSYS GLP with root count only option. Homotopy Solution Our parallel POLSYS GLP algorithm computed 42,786 solutions in 42 minutes using 128 nodes of Blue Horizon. This is approximately 626 paths/processor-hour. Each real solution can be used to design an RRS chain to reach the specified displacements. The distribution and utility of these solutions requires further study. 109

133 4.11 Summary This chapter presents the formulation and solution of the design equations for the synthesis of seven serial chains, denoted the PPS, TS, RPS, CS, PRS, right RRS and RRS chains. Each of these is characterized by the equation of the surface that contains the center of its spherical joint. By evaluating the equation of this surface for each of a given set of task positions, we obtain a polynomial system that defines the chain. The GLP structure of this polynomial system is determined in each case and used to compute a bound on the number of roots. The polynomial homotopy solver POLSYS GLP was used to determine the solutions to randomly specified design problems for all seven cases. The result is a generic root count for each of these design problems, Table 4.2. Due to the complexity of the last three problems, the root count may vary in different runs. Nevertheless, the solutions obtained provide candidate designs for the task. 110

134 Chapter 5 Design of Serial and Parallel Robots 5.1 Overview The kinematic synthesis of constrained robotic systems can be simplified by specifying values for certain dimensional parameters and solving a smaller set of equations for the remaining design parameters. This allows the designer to trade control of the task against a direct specification of the robot geometry. Here we study the cases that arise for the CS and RPS serial chains when values for certain design parameters are specified by the designer. We label these cases CSn and RPSn, where n denotes the number of task positions required to specify the remaining parameters. The cases CS3-8 and RPS6-10 are presented together with a collection of sub-cases that arise from choices available for the specified parameters. Numerical examples are provided for CS6 and RPS8 in which two design parameters 111

135 are specified so six and eight task positions, respectively, are required to complete the design of these chains. We also consider the design of a symmetric 3RRS parallel robot. In this example, the dimensions of three identical RRS chains are obtained so the symmetrically positioned legs can guide its platform through two positions. 5.2 Design of CS Robot A CS robot is formed by a cylindric joint and a spherical joint with one end connected to the base and the other equipped with an end-effector. The goal of the synthesis problem is to determine the dimensions of the CS robot such that its end-effector passes through a given set of task positions. In Chapter 4, we have shown that this problem is equivalent to determine a circular cylinder traced by the S-joint of the robot. See design equations (4.31). Eight parameters are required to determine a circular cylinder, three for p = (p 1, p 2, p 3 ), three for B = (b 1, b 2, b 3 ) and two for G = (g 1, g 2, g 3 ). Thus, we can specify up to n = 8 arbitrary task positions. We have also provided a homotopy solution to eight position synthesis problem CSn Design Problems However in practice, we would rather specify a set of the dimensional parameters and thereby reduce the number of task positions for the design problem. In particular, 112

136 if the designer chooses to specify j dimensional parameters, then the associated task would have n = 8 j positions. Now we denote by CSn the n position design problem for CS serial chain. The design equation for CSn problem is obtained by reformulating the equation (4.31). For simplicity, we substitute the two linear equations into the n 1 quartic equations to eliminate g 3 and b 3 without losing generality. Thus, the design equations for CSn design become C i = (P i G) 2 (P 1 G) 2 2((P i P 1 ) G) (B G) = 0 i = 2,...n, (5.1) where (p 1, p 2, p 3, b 1, b 2, g 1, g 2 ) T are the eight unknowns. Recall P i = [T i ]p is a linear function of p 1, p 2, p 3, where [T i ] are the task positions. And the associated GLP structure (4.33) becomes C i g 1, g 2 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, b 2, 1 i = 2,...n. (5.2) To tabulate the possibilities, let g 2, p 3, and b 2 be the number of unknowns in (g 1, g 2 ), (p 1, p 2, p 3 ), and (b 1, b 2 ), respectively, with g + p + b = n 1. The case n = 8 allows no component to be specified. For n = 7, one component can be specified. Depending on which group the specified component is from, we obtain three cases CS7a, CS7b and CS7c. We specify G when possible, which means we have g = 0 for all of n 6. This reduces the quartic constraint equations to quadratics. Table 5.1 shows the combinations of specified parameters and tasks that are available. For each of our design problems in Table 5.1, we calculate the GLP bound on root count as follows. First, we take g terms of the form g 1, g 2 from the n 1 = g +p+b 113

137 Name n g p b Deg B GLP CS3a CS3b CS3c CS4a CS4b CS4c CS5a CS5b CS CS7a CS7b CS7c CS Table 5.1: The GLP bound on CSn design problems. The bound is exact for n 6. design equation (5.2). Since the degree of the set g 1, g 2 is two, we have two choices, which means the number of combinations is ( ) g + p + b 2 g. (5.3) g Next, we can use j = 0 up to j = p terms of the form p 1, p 2, p 3, 1 and combine them with p + b j terms taken from those of the form p 1, p 2, p 3, b 1, b 2, b 3, 1 to define the p + b unknown parameters among (p 1, p 2, p 3 ) and (b 1, b 2, b 3 ). This yields the combinations p ( ) p + b. (5.4) j j=0 Finally, combining these results, we obtain the GLP bound for CSn design problems 114

138 Name CS7a CS7b CS7c CS8 n B GLP Roots Time 0h6m 0h16m 0h14m 1h02m Table 5.2: Homotopy solution to the CS7 and CS8 design. Run time is obtained by executing POLSYS GLP on a Pentium 4 1.5GHz system. as ( ) p g + p + b B GLP (g, p, b) = 2 g g i=0 ( p + b i ). (5.5) The values of this formula for the various designs are shown in Table 5.1. For 3 n 6, we have always specified G. Thus the GLP structure (5.2) becomes C i (z) p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, b 2, 1 i = 2,...,n. (5.6) And the formula (5.5) for computing GLP bound is simplified to B GLP (p, b) = p ( ) p + b, (5.7) i i=0 where we have substituted g = 0. The values of this formula for the various designs are shown in Table 5.1. Later we provide a resultant solution to these cases and found that the GLP bound is exact for 3 n Homotopy Solution to CS7 and CS8 Design For cases CS7 and CS8, the GLP bounds listed in Table 5.1 are large, so we attack these with polynomial homotopy method. We do not know at the outset whether the 115

139 Case GLP Structure Sol. Case Matrix Root in Table 3.1 Size Count CS3a b 1, b 2, CS3b p 1, 1 p 1, b 1, CS3c p 1, p 2, 1 p 1, p 2, CS4a p 1, 1 p 1, b 1, b 2, CS4b p 1, p 2, 1 p 1, p 2, b 1, CS4c p 1, p 2, p 3, 1 p 1, p 2, p 3, CS5a p 1, p 2, 1 p 1, p 2, p 3, b 1, CS5b p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, CS6 p 1, p 2, p 3, 1 p 1, p 2, p 3, b 1, b 2, Table 5.3: Resultant solution to the CS3-6 design problems. GLP bounds are sharp. By solving a generic example of each case, we can determine the exact root count for each problem. If it were to happen that the count is small, one could then be encouraged to look for an elimination method. Since the number of homotopy path or the GLP bound is not very high, one processor is enough. Therefore we use POLSYS GLP to compute the roots for random test cases on a 1.5GHz Pentium 4 system. For each task position, we used a random number generator to obtain 7 numbers. Three are used as the position vector and the other 4 are normalized to a unit quaternion representing spatial orientation. With probability one, such a set of tasks will be generic; that is, the number of solutions to the synthesis problem defined by the tasks will be the generic root count. Some paths diverge to infinity, leaving a reduced number of finite roots. The root counts and execution time for the runs are summarized in Table

140 5.2.3 Resultant Solution to CS3, CS4,CS5 and CS6 Design For 3 n 6 task positions, the GLP bounds shown in Table 5.1 are low enough to suggest that an elimination procedure may be convenient. Notice polynomial system (5.6) has a quasi-quadratic structure because it is linear with respect to b 1, b 2. In Section 3.5, we have provided a resultant elimination solution to a series of quasi-quadratic polynomial systems. Therefore for each case of 3 n 6, we can obtain the solutions by referring the solution formulation in Table 3.1. Let s use CS6 design problem as an example to describe how to use Table 3.1. There are l = 3 quadratic variables (p 1, p 2, p 3 ) and m = 2 linear variables (b 1, b 2 ). We look up the case l = 3 and m = 2 in Table 3.1 to identify the case index which is 4. Therefore by following the same resultant elimination steps, we obtain a full rank matrix which can be reduced to a generalized eigenvalue problem to obtain 26 solutions. The results are summarized in Table 5.3. The third column corresponds to the case index shown in Table 3.1. The fourth column shows the size of the resultant matrix, which can be reduced to generalized eigenvalue problem to obtain the solutions. And the last column provides the root count which equals the GLP bound B GLP shown in Table

141 x y z Long. Lat. Roll T T T T T T Table 5.4: A set of six task positions for the CS6 design problem that has 26 real solutions A Numerical Example for CS6 Design The generalized eigenvalue solution for the case CS6 has been implemented using Java and integrated into our synthesis software Synthetica, which allows the designer to specify the spatial task and then view and evaluate the resulting serial chains. Since the average running time of the resultant solutions is only 40ms on a 1.5GHz Pentium 4 system, we wrote a Java program that generates five random task matrices (the other is fixed as identity matrix) with position limited in the box x < 2.0, y < 2.0, 0.0 < z < 2.0 and random orientation which is computed from a random quaternion. After solving about two million such task sets (took 20 hours), we found 11 examples that have 26 real solutions. One of the examples that has all real solutions is as follows. The six task positions are listed in the Table 5.4. The chosen vector G = (0.7831, , ), and the random plane for defining B is n = (0.0879, , 1), f = The

142 Sol. b 1 b 2 b 3 p 1 p 2 p Table 5.5: The 26 CS chains that reach six specified positions. real solutions computed by the eigenvalue method are listed in the Table 5.5. Figure 5.1 shows the 4th solution reaching the six design positions. 5.3 Design of RPS Robot A RPS serial robot is a generalization of CS robot in that the R-joint and P-joint axes are not parallel. As a result, the S-joint of an RPS robot lie on a circular hy- 119

143 [T2] [T1] [T3] [T4] [T5] [T6] Figure 5.1: The 4th CS chain of Table 5.5 is shown reaching the six design positions. perboloid (Figure 4.6). In Section 4.8, we have shown that ten parameters determine a circular hyperboloid, two for G = (g1, g2, g3 ), three for p = (p1, p2, p3 ), three for K = (k1, k2, k3 ) and one for k0. Thus, ten arbitrary task position can be specified for designing a RPS robot. 120

144 Name n g p k Deg B GLP RPS6a RPS6b RPS6c RPS7a RPS7b RPS RPS9a , RPS9b , RPS9c , RPS , Table 5.6: The GLP bound on RPSn design problems. The bound is exact for n RPSn Design Problems However it would be more practical to specify fewer task positions and control geometric parameters. If the designer chooses j parameters, then a RPS robot can be designed to reach n = 10 j task positions. Now we use RPSn to denote the n position design of RPS serial chain. The design equations for RPSn problems are obtained by reformulating the equation (4.45). For simplicity, we substitute the last linear equation into the other n 1 equations to eliminate the variable g 3. Thus the design equations for RPSn problems are given by H i = k 0 (P i P i P 1 P 1 )+2K (P i P 1 ) (P i G) 2 +(P 1 G) 2 = 0 i = 2,..., n, (5.8) which consist of (g 1, g 2, p 1, p 2, p 3, k 0, k 1, k 2, k 3 ) T total nine unknowns. The GLP struc- 121

145 Name RPS9a RPS9b RPS9c RPS10 n B GLP Roots Time 1h15m 0h52m 3h40m 10h58m Table 5.7: Homotopy solution to RPS9 and RPS10 design problems. Run time is obtained by executing POLSYS GLP on a Pentium 4 1.5GHz system. ture (4.47) becomes H i g 1, g 2 2 p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, k 3, 1 i = 2,..., n (5.9) As in the case of CS robot, we also consider various cases of this problem. Let g 2, p 3 and k 4 denote the number of unknown design parameters among (g 1, g 2 ), (p 1, p 2, p 3 ) and (k 0, k 1, k 2, k 3 ), respectively notice that g + p + k = n 1, which is the number of design equations in (5.8). Notice this structure is similar to that of C i in (5.6). Therefore the GLP bound on the root count can be similarly written as B GLP (g, p, k) = 2 g ( g + p + k g ) p ( p + k j=0 j ). (5.10) For n 8, we always choose to specify the axis G of the R-joint since the design equations reduce to quadratic form. Thus the GLP structure becomes H i p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, k 3, 1 i = 2,..., n, (5.11) which are again in quasi-quadratic form. The associated GLP bound is given by B GLP (p, k) = p ( ) p + k. (5.12) j j=0 122

146 Case GLP Structure Sol. Case Matrix Root in Table 3.1 Size Count RPS6a p 1, 1 p 1, k 0, k 1, k 2, k 3, RPS6b p 1, p 2, 1 p 1, p 2, k 0, k 1, k 2, RPS6c p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, RPS7a p 1, p 2, 1 p 1, p 2 p 1, p 2, k 0, k 1, k 2, k 3, RPS7b p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, RPS8 p 1, p 2, p 3, 1 p 1, p 2, p 3, k 0, k 1, k 2, k 3, Table 5.8: Resultant solution to the RPS6-8 design. The results are summarized in Table Homotopy Solution to RPS9 and RPS10 Design As it turns out, the GLP bounds for the cases RPS9a, RPS9b, RPS9b and RPS10 are not sharp, but the number of roots is still too large to make an elimination approach desirable. Therefore we apply POLSYS GLP homotopy solver to attack these problems. To obtain a generic root count for each of these problems, we also used randomly specified task positions as for CS7-8 design cases. The results are shown in Table 5.7. The run time is obtained on a Pentinum 4 1.5GHz PC. It is interesting to notice that the actual number of roots far less than the total degrees of these polynomial systems, and an order of magnitude less than the GLP bounds. 123

147 x y z Long. Lat. Roll T T T T T T T T Table 5.9: A set of eight task positions for RPS8 design Resultant Solution to RPS6, RPS7 and RPS8 Design The GLP bounds for RPS6, RPS7 and RPS8 problems (Table 5.6) are low enough that we seek a resultant elimination procedure to find all the roots for these design problem. As in the cases CS3-CS6, the design equations for these case also have quasi-quadratic structure (5.11). Therefore for each case of RPS6, RPS7 and RPS8 design problems, we refer the corresponding resultant formulation in Table 3.1 for solution. And the results are summarized in Table 5.8. Notice the root counts in the fourth column show that the GLP bound B GLP are exact for these cases A Numerical Example for RPS8 Design We have implemented the resultant solution for the case RPS8 in Java which has been integrated into our synthesis software Synthetica. Test problems show that the average solution time is 0.3 seconds on a 2.4GHz Pentium 4 system. 124

148 Sol. a 2 b 2 b 1 b 2 b 3 p 1 p 2 p Table 5.10: The 19 RPS chains that reach eight task positions. An example of eight random task positions are listed in the Table 5.9. The direction of R-joint axis was randomly chosen to be G = ( , , ). The computation yields 36 real solutions among a total of 64 roots, however only 19 of these have physical meaning, Table This is due to the requirement that a 2 > 0 and b 2 > 0 (tan 2 α > 0). Recall tan α = a/b. See Figure 4.6 for dimensions a and b. Figure 5.2 demonstrates the solution no. 8 reaching each of the eight specified task positions. 125

149 Figure 5.2: The 8th RPS chain of Table 5.10 is shown reaching the eight task positions. 5.4 Design of 3RRS Parallel Robot A 3RRS parallel robot is a three degree-of-freedom platform constructed from three RRS serial chains. The dimensional synthesis of this system is obtained using design equations for each of three RRS chains which has been derived in Chapter

150 M n M 1 M P 1 p 1 p 2 p 3 P 3 R P 2 R H 3 ρ H 1 R ρ G 1 H 2 B 3 B 1 ρ G 3 G 2 B 2 Figure 5.3: A symmetric 3RRS parallel platform A Symmetric 3RRS Parallel Robot Here we consider a symmetric case of 3RRS parallel robot, formed by a moving platform that is connected to a fixed base by three identical limbs. See Figure 5.3. Each limb is a right RRS serial chain, that is, the two R-joint axes are perpendicular. Let G i and H i represent the two R-joint axes of the ith limb. We have G i H i. Let v i be their common normal with ρ i as the normal distance. The intersection of v i with G i and H i are denoted by the points B i and Q i respectively. Let the position of the S-joint be the vector P i and R i be the normal distance from P i to the axis H i. The location of the S joint of the ith limb is defined in the moving frame by the vector p i. Its coordinates in the fixed frame are given by P i = [M]p i, where [M] is 127

151 the 4 4 homogeneous transform that defines the location of the moving platform. The three grounded R-joints and S-joints are located on a circle separated by 120 degrees on the base and the platform, respectively. All three limbs have the same dimensions ρ 1 = ρ 2 = ρ 3 = ρ, and R 1 = R 2 = R 3 = R. (5.13) And the normal points B 2 and B 3 can be determined by rotating B 1 around the z-axis by 2π/3 and 4π/3 radians, respectively. The vectors G 2, G 3 and p 2, p 3 can be determined in the same way. We have B 2 = [Z(2π/3)]B 1, B 3 = [Z(4π/3)]B 1, G 2 = [Z(2π/3)]G 1, G 3 = [Z(4π/3)]G 1, and p 2 = [Z(2π/3)]p 1, p 3 = [Z(4π/3)]p 1, (5.14) where [Z(θ)] is the 4 4 transform that defines a rotation by θ around z-axis Design Equations The center of the S-joint of a right RRS chain traces a right circular torus (Figure 4.7). The design equations for one right RRS chain are given in (4.56). The design equations for the 3RRS platform are defined writing the design equations for each of the three RRS chains, that is, ((P k 1 B 1 ) 2 ρ 2 R 2 ) 2 + 4ρ 2 ((P k 1 B 1 ) G 1 ) 2 4ρ 2 R 2 G 2 1 = 0, k = 1,...,n; ((P k 2 B 2) 2 ρ 2 R 2 ) 2 + 4ρ 2 ((P k 2 B 2) G 2 ) 2 4ρ 2 R 2 G 2 2 = 0, k = 1,...,n; ((P k 3 B 3 ) 2 ρ 2 R 2 ) 2 + 4ρ 2 ((P k 3 B 3 ) G 1 ) 2 4ρ 2 R 2 G 2 3 = 0, k = 1,...,n, (5.15) 128

152 Platform Task Positions Free Parameters 3RRS RRS 2 2 5RRS 2 0 Table 5.11: The number of task positions and free parameters for symmetric 3RRS, 4RRS and 5RRS platforms. where P k i = [Mk ]p i is the position of S-joint of chain i when the end effector is located at the kth task position. Equation (5.15) consists of 10 independent design parameters z = (ρ, R,B 1,p 1,G 1 ) note G 1 is a unit vector so it has only two independent parameter. Equations (5.13) and (5.14) define the remaining dimensions of the limbs supporting this platform in terms of the elements of the design vector z Design Problems Because we can have no more than 10 design equations, we find that the number n of task positions must satisfy the condition 3n 10. The result is two basic design problems (i) two task positions (n = 2), which allows the values of four dimensional parameters to be selected by the designer, and (ii) three task positions (n = 3), which allows one dimensional parameter to be selected. It is interesting to note that design equations for symmetric 4RRS and 5RRS platforms can be defined in the same way. The 4RRS platform has two degrees-offreedom, and each task position requires four equations similar to (5.15). This means 129

153 joint α a θ d θ θ θ θ θ 5 0 Table 5.12: The Denavit-Hartenberg parameters of solution 4 in Table 5.14 it can be defined to reach two task positions with two free parameters that can be specified by the designer. The 5RRS platform has one degree-of-freedom and can be designed to reach two task positions with no extra free parameters. These results are summarized in Table A Homotopy Solution and Numerical Example As an example of the design of a symmetric 3RRS chain, we solve the two position case with G, p z and B z chosen. This requires the solution of six quartic equations which form a polynomial system of total degree 4 6 = 4, 096. For comparison, the three position case requires the solution of nine equations of degree five with a total degree of 5 9 = 1, 953, 125 where we have treated ρ 2 and R 2 as independent variables. The 4 4 matrices defining the task positions of the end-effector are given by M 1 = (5.16)

154 chain θ 1 ( ) θ 2 ( ) θ 3 ( ) θ 4 ( ) θ 5 ( ) Table 5.13: Joint parameters for task positions 1 and M 2 = (5.17) The two position problem provides the designer the freedom to specify four of the dimensional parameters of the 3RRS platform. In this example we chose the axis G 1 to be along the z-axis, that is G 1 = (1, 0, 0), as well as the parameter values B z = 0 and p z = This places the base in the x-y coordinate plane of the fixed frame, and the platform slightly below the x-y plane of the end-effector frame. Our execution of POLSYS GLP for this set of design equations yielded 70 real solutions, which are listed in Tables 5.14 and As an example we present the table of Denavit-Hartenberg parameters (Table 5.12) for the 4th solution the three RRS chains are identical and have the same set of DH parameters. Table 5.13 defines the joint angles of each RRS chain that positions the platform in the two task positions. Figures 5.4 illustrates the movement of our 3RRS platform between the two task 131

155 M 1 M 1 M 2 M 2 Figure 5.4: A symmetric 3RRS platform reaching the two task postions. positions M 1 and M 2. The light set of frames is the desired trajectory obtained by built-in interpolation routine of our software Synthetica. The dark set of frames is the actual trajectory within the workspace of the platform, obtained by the trajectory planning routine presented in Chapter Summary In this chapter, we considered design problems in which certain parameters for the CS and RPS chains are specified. For the cases denoted CS3-6 the design equations simplified so that it is possible to find algebraic solutions using sparse resultants. The cases CS7 and CS8 required numerical solution using our polynomial homotopy algorithm POLSYS GLP. Similarly, the cases RPS6-8 were solved algebraically, while RPS9 and RPS10 were solved using POLSYS GLP. Example solution of the CS6 and RPS8 cases yielded 26 and 36 real roots, respectively. 132

156 We also examined the design of a symmetric parallel robot with RRS chains as legs. Requirements that the legs be identical and the base and platform be planar impose dimensional constraints that yield six design equations for two task positions. This system has total degree In the example, POLSYS GLP computed 70 real roots. 133

157 Sol. ρ R B x B y p x p y Table 5.14: Real solutions 1-35 for 3RRS two position synthesis. 134

158 Sol. ρ R B x B y p x p y Table 5.15: Real solutions for 3RRS two position synthesis. 135

159 Chapter 6 Synthetica 6.1 Overview In this chapter we present the robotic system design software Synthetica. This software is a set of Java classes organized in packages with a graphical user interface and general kinematic solver and path planner. We first describe the architecture of Synthetica which is tailored to provide a variety of linkage synthesis routines in an interactive environment. It is modeled on the engineering design process, but focussed on the dimensional synthesis of constrained serial chains. Complex systems can be obtained by assembling several serial chains in parallel. Synthetica integrates the general analysis and trajectory planning routines described earlier that facilitate the evaluation of design candidates. The Java classes are organized into four packages, three of which provide mathematical functions, 3D graphics primitives and user-interface functions. The fourth package mechanism provides the data structure for various serial and parallel chains, 136

160 and their analysis and synthesis routines. New serial and parallel chains are added to Synthetica by extending this mechanism package. We demonstrate this by providing a step-by-step description of the routines necessary to integrate spatial RR chain synthesis. 6.2 Software Architecture Our goal is to develop a spatial linkage design system that is structured so that it can be extended by user-collaborators to include a broad range of spatial linkage topologies of interest to the designer. We have examined existing computer-aided linkage design systems and identified a fundamental structure that we believe is generic to the function-to-form process for spatial linkages. This model contains five stages simplified from Erdman and Sandor s Seven Stages of Computer-Aided Engineering Design (1997) [14]. Here we confine its scope to the synthesis of serial chain primitives (planar, spherical and spatial) and the analysis of parallel linkages assembled from these primitives. Figure 6.1 shows the key modules and flowchart of Synthetica. First through the ClassLoader module, Synthetica loads in all available synthesis routines (in the form of Java classes) developed by the external users. At this point, the user can either create a linkage through TopologySpecifier and DimensionSpecifier or synthesize one. When the user choose the synthesis mode, the following stages are executed. Stage 1: Task Specification 137

161 Figure 6.1: The architecture of Synthetica. First the designers formulate a synthesis problem into the concrete, quantitative from, termed design task. In Synthetica, a design task is modeled as a set of discrete positions in space plus a set of user specified parameters. These positions represented 4 by 4 homogeneous matrices, are the desired workspace of a constrained robot to be determined. Synthetica provides a TaskSpecifier module for the users to dynamically specify task positions. In addition, a motion interpolation using quaternion representation is integrated for users to adjust a 138

162 design task. Stage 2: Mechanism Topology Selection With a given design task, the designers select a preferred linkage topology as candidate. Synthetica then prompts a DesignMatrix table in which the available solutions to the task are listed for selection. The designers can either pick an available solution or develop a new one for the problem. The later choice allows advanced users develop new synthesis routines for Synthetica. See Section 6.5 for the rules of developing new routines. Stage 3: Dimensional Synthesis Once the design task, mechanism topology and synthesis routine are all specified, Synthetica compares the number of positions and the number of free parameters in the constraint equations to determine what additional constraints are needed to fully specify a solution to the problem. These extra information includes free parameters, optimization requirements, dynamic and force requirements. Then the system invokes the corresponding synthesis routine to obtain solutions. Stage 4: Evaluation, Analysis Typically, synthesis routines lead to a set of candidates which are accessible through the MechanismViewer module. The evaluation module determines whether a candidate satisfies the specifications and eliminates defect solutions. At this point, it is optional to save the linkage candidates to a local data file 139

163 for further study. Stage 5: Presentation At last, Synthetica provides tools to display/animate the candidate linkages. A 3D OpenGL base display routine visualizes the linkage. A tree structure is developed for manipulating objects in the scene. Synthetica also provides a build-in trajectory planning routine which can generate animation by approximating the desired workspace. At each stage, Synthetica allows the designers change design requirements and repeat the process until a satisfactory design is obtained. 6.3 Functionalities and Features The goal of Synthetica is to provide a platform for researchers to collaborate on the mechanism synthesis and analysis. Synthetica provides the following functionalities: Dimensional synthesis of spatial mechanisms Dimensional synthesis starts with specifying a design task and a linkage topology. Synthetica tabulates all the available synthesis routines that can provide a solution. And then Synthetica executes the synthesis routine with the specified task as input data. The result is a set of candidates for the design task. Kinematic analysis for serial and parallel linkages 140

164 Synthetica provides a general kinematics solver for serial and parallel linkages. These linkages are either obtained from the synthesis solver or modeled by specifying the topology and dimensions. The parallel linkages are formed by assembling multiple serial chains. These routines are accessible to users through the graphical user interface. Trajectory planning In Synthetica, users can generate a design task using the built-in routines. A design task is modeled as an array of positions in the form of 4 by 4 matrices together with an array of constraints (free parameters). Users can place a set of key positions and then interpolate these position to obtain a goal continuous trajectory in space. Furthermore, this goal trajectory can be approximated to obtain the actual one using an optimization based algorithm. To allow collaborators develop independently with their own software development resources, we require the software be portable, extensible and platform independent. This is well suited for an implementation using Java. Synthetica has the following features: Extensibility and collaboration The architecture of Synthetica is designed to be extensible so that external routines can be integrated into the system conveniently. This is done by taking advantage of Java s built-in capabilities to dynamically inspect class contents at runtime. This feature is represented in Figure 6.1 by the ClassLoader. Syn- 141

165 thetica provides infrastructure for these developers by providing standardized user interface and graphical simulation functionality. Portability Since Synthetica is developed in Java 2, it is naturally platform independent. Currently it has been tested on Windows 98/2000/XP and Mac OSX. Cross platform compatibility is complicated by two factors; (i) different web browsers accommodate different Java Virtual Machines, and (ii) OpenGL links to Java currently are platform dependent. However, once the proper libraries are installed, the same Java code can be compiled to run on any of the supported operating systems. Graphical user interfaces Synthetica provides a rich graphical user interfaces (GUI) based on Java Swing package. Figure 6.2 shows a sample Synthetica desktop. A tree structure is used to manage the 3D objects (mechanisms, design tasks, trajectory etc.) in the scene. An animation bar is used to animate the mechanisms. These GUI components allow users to access the routines embedded in the system conveniently. See Appendix B for more on GUI components. 3D interactive displayer Synthetica uses GL4Java [24], a JNI encapsulation of the OpenGL graphics library, to generate and display mechanism models in real-time. Users can rotate, pan, and zoom in/out the scene dynamically. Also users can modify the 142

166 1. Toolbar: file I/O, add/remove/turn on off objects 2. Object Tree: select object for manipulation 3. Info Panel: show object data (mechanism dimensions, link properties etc.) 4. Teach Panel: drive joint parameters 5. Workpiece: shows the position and orientation of the end-effetor 6. Interactive Viewer: dynamically display the objects 7. Animation Bar: animate the selected animation object Figure 6.2: The desktop of Synthetica. mechanism properties such as color and material through the object information panel. The scene background settings can be changed through the OptionDialog (Figure B.3). Data file I/O Synthetica allows users to read and write object data from and to local files. Most of our classes in the package mechanism have implemented the Serializable 143

167 Figure 6.3: Synthetica package organization. interface. As a result, these mechanism objects can be exported and imported through Java s object serialization functionality. 6.4 Synthetica Packages Synthetica consists of four major components organized into Java packages as shown in Figure 6.3. The main program integrates and coordinates the flow of information using the four underlying packages: mechanism, GUIModules, glprimitives, kinemath. In what follows, we describe each package in more details. 144

168 6.4.1 Package mechanism Figure 6.4: Mechanism package organization. The mechanism package provides the classes which define the data structure of spatial linkages as well as a number of key interfaces for implementing special purpose analysis and synthesis routines. The package is designed using the subclassing architecture of the Java language specification. The mechanism package hierarchy shown in Figure 6.4. This subclassing hierarchy follows the is-a rule of object-oriented programming (OOP). For example, the class JointR which defines a revolute joint as a special case of a general joint. Therefore 145

169 it is natural to extend the class JointR from the class Joint. Also since SerialMechanism is a special case of a general mechanism, we extend the class SerialMechanism from the class Mechanism. Note that the lines with arrows represent the inheritance relationship and the data in the parentheses represent the key fields in the class. For example, a SerialChain object is a primitive that has an array of joints and an array of links. This relationship is called has-a relationship in OOP. The DesignTask class defines the positions and constraints required by a synthesis routine. We have also defined four Java interfaces. The ForwardKinematics and InverseKinematics interfaces specify the methods required for linkage position analysis. The Synthesizable interface specifies a set of methods for defining default tasks, constraint names, and for performing dimensional synthesis. The Drawable interface provides the programmer with the ability to create customized geometry for the mechanisms. Advanced users can define new synthesis/analysis/drawing routines by implementing these interfaces. For example, one user comes up an analytical routine for the spatial RR synthesis. He or she can extend a new class from the class SerialMechanism and implement the interface Synthesizable and fill the codes in the method Mechanism[] synthesize(designtask). See Section 6.5 for an example. Appedix C provides a list of source code for some key classes of packagemechanism Package GUIModules The GUIModules package provides the dialog boxes and panels that allow users to modify/view the data associated with synthesis or analysis tasks. In what follows, 146

170 Figure 6.5: DesignMatrix panel allows users to select a synthesis routine. we describe the three key interfaces DesignMatrix, TaskSpecifier and MechanismViewer. More GUI components can be found in Appendix B. The DesignMatrix panel When the Synthetica loads, the available mechanism and synthesis classes are inspected to determine the mechanism topology, and task characteristics. This information is saved in a map and presented to the user in the DesignMatrix (Figure 6.5). The ability to load and view the contents of an arbitrary class allows us include classes generated by other programmers. The class specifications defined in the mechanism package ensures that the classes contain all the information we need to integrate them into our list of mechanisms and synthesis routines. 147

171 Add a new task position from the Workpiece data Choose a key frame to work on Remove the selected task position Standard 4 by 4 matrix panel Add a free parameter Parameter value Remove this free parameter Figure 6.6: TaskSpecifier panel for specifying a design task. The TaskSpecifier panel A task is defined by its number of positions and additional constraints. This information is used to dynamically generate the TaskSpecifier panel (Figure 6.6) which directs the user to enter all the information required by the particular synthesis routine. Position and constraint defaults are provided along with a listing of constraint names. The MechanismViewer panel An information panel is generated for each serial chain, and presented together in the MechanismViewer panel (Figure 6.7). Each information panel contains a DH table for showing Denavit-Hartenberg parameters, a panel showing a base frame and a gripper, 148

172 Click to choose another chain to work on Add a sub chain before Remove this chain Insert a sub chain after Replace this chain Denavit-Hartenberg table for this serial chain Click to launch matrix4d specifier for changing base frame Click to launch matrix4d specifier for changing gripper frame Click to change the link material Figure 6.7: MechanismViewer panel displays data structure of mechanisms. and link property panel showing the link materials and scale. See Figure 2.2 for a standard serial chain model. This allows us to display all the chains associated with a parallel linkage topology in a single tabbed panel. For parallel mechanisms, user can add, remove and replace a sub chain. The joint parameters are displayed in a separate mechanism teach panel (Figure B.9) Package glprimitives The glprimitives package provides the 3D graphics functionalities for the main program. It uses GL4Java that provides access to the OpenGL functionalities on the client machine to generate and display mechanism models in real-time. GL4Java 149

173 package is available for both Macintosh and Windows operating systems and can be downloaded for free. A full list of classes of the package glprimitives can be found in Figure Package kinemath The kinemath package provides basic mathematical resources used by other parts of the program. It allows programmers to conveniently access mathematics operations such as vector, matrix, quaternion manipulation, and kinematics operations such as motion interpolation. The javax.vecmath package is used extensively; this package is distributed with Java3D, but is independent of the Java3D specification and implementation. A full list of classes of the package kinemath can be found in Figure Implementing Routines for Synthetica Synthetica is structured to serve two roles. It can run as a standalone application/applet which causal users execute to synthesize and analyze implemented mechanisms. It is also a programming package. Advanced users can define their own mechanisms and implement their own synthesis or analysis algorithms. At runtime, the program examines the contents of these classes to determine the mechanism topology and design task information needed to construct the DesignMatrix table. 150

174 6.5.1 Implementation Steps The following steps are used to implement mechanism classes and synthesis routines for Synthetica: 1. Create a new class by extending a base mechanism class, SerialMechanism or ParallellMechanism depending on the mechanism topology. This class should be declared as part of the package client. 2. Specify the topology and default dimensions of the mechanism in the constructors of this new class. 3. Implement one or more interfaces Synthesizable, ForwardKinematics, InverseKinematics, and Drawable as needed. Synthetica provides a default Drawable for all mechanism classes and a default ForwardKinematics for all serial mechanisms. Developers can override these routines when necessary. 4. Compile and link the source code together with the Synthetica API. This results a.class file. 5. Place the new.class file in the class path that is accessible to Synthetica and run Synthetica which loads in this new.class file through the ClassLoader module. 6. The information found in the new class will be mapped into the DesignMatrix or MechanismViewer module depending on which interface has been implemented. 151

175 7. Invoke the synthesis or analysis routine through the GUIs as if it is a built-in routine Example Integration We now show an example for implementing two routines for a spatial RR chain, one is a closed form inverse kinematics routine and the other is an analytical synthesis routine for three position synthesis routine which is based on the formulation proposed in [48]. We first from the the base class SerialMechanism extend a new class named Serial RR 3Pos 0Con, where Serial means a serial chain, RR is the topology, 3Pos and 0Con denote that a task with three position and no free parameters is accepted for the synthesis routine. In the constructor, we define RR as the mechanism topology. Two interfaces InverseKinematics and Synthesizable are implemented. The associated code is filled in the methods inversek and synthesize respectively. The skeleton of this class is listed as below. The full source code of Serial RR 3Pos 0Con.java can be found in Appendix C. package client; /*declare this class is part of the package client*/ /* necessary imports */ class Serial_RR_3Pos_0Con extends SerialMechanism implements InverseKinematics, Synthesizable { /* define mechanism topology and associated data in the constructor */ public Serial_RR_3Pos_0Con(){ super("rr"); //RR is the topology of this mechanism

176 ... /* override default inverse kinematics function */ public double[][] inversek(matrix4d T) {... /* implement 3 position synthesis method */ public Mechanism[] synthesize(designtask task) { /* Get design position and free parameters from the task*/... /* Solve the design equation to determine the mechanism dimensions*/... /* Construct the mechanism object from the dimensions */ Compile the source codes with Synthetica into a Serial RR 3Pos 0Con.class file. Place the Serial RR 3Pos 0Con.class in the class path. Synthetica loads the class file in and made the inverse kinematics and synthesis routine available for the users. 6.6 Example of the Use of Synthetica In this section, we perform the three position synthesis of spatial RR chain as an example to demonstrate the usage of Synthetica. We assume that the synthesis algorithm has been implemented as in the Section 6.5. Now we show the usage of this synthesis routine. Launch Synthetica 153

177 The loading process is shown in a startup flash window. A desktop similar to Figure 6.2 appears when the loading finished. You will see a default floor, a global coordinate frame and a work-piece in the scene. If any problem occurs in this step, please refer the user s guide in Appendix B. Create a design task 1. Select the DesignTasks node in the tree structure and click the Add Object icon on the toolbar. A default design task shows up in the scene. Also a new leaf node is added to the root node DesignTasks. 2. Select the new node to display the task information in the DesignTask panel (Figure 6.6) and change default values to the desired. Since an RR chain can be synthesized to reach three positions, a design task with three task positions and no constraints is required. Synthesize RR serial chains 1. Select the Synthesis node and click the Add Object icon. A dialog box with a list of design tasks shows up. 2. Choose the desired design task from the list. Please select the design task with three positions has been created earlier and click Ok. A DesignMatrix dialog (Figure 6.5) appears. 3. Identify the RR three position synthesis routine by looking up the DesignMatrix dialog for the topology RR in the columns and number of 154

178 positions 3 in the rows. Click the item to show the information on the routine. 4. Click Ok to invoke the corresponding synthesis routine. The computation is carried out in the background. When synthesis routine returns, the candidate mechanisms are listed under the tree structure for evaluation. Evaluate the candidates The three position synthesis for spatial RR chain always returns two real solutions which are listed under the root node SerialMech. 1. Select any one solution to display the geometric information of the mechanism in the MechanismViewer panel (Figure 6.7). Designers can examine Denavit-Hartenberg parameters as well as the information on base and gripper frame in this panel. 2. Drive the two revolute joints by changing the joint parameters in the MechTeach panel (Figure B.9) (lower right side of the window). 3. To invoke the inverse kinematics, one can click the Reach button on top of the mechanism teach panel. If a closed-form inverse kinematics for spatial RR chain is not implemented in the selected class, the built-in general solver will be used to solve for joint parameters. Export the objects to a local file At this point, users can save the objects under the tree nodes to a local file by 155

179 using the menu items or their corresponding icons on the toolbar. Afterwards, this file can be opened for further evaluation. 6.7 Summary This chapter describes the architecture of the robot synthesis software Synthetica. This software is extended to include analysis and synthesis routines for new serial chains by extension of the package mechanism. An example implementation of routines for a spatial RR chain illustrate this process. Finally, a detailed example of the use of Synthetica for the synthesis and analysis of a constrained serial chain robot is provided. 156

180 Chapter 7 Conclusions and Future Research The goal of this research was to develop computational and software tools for design of spatial robotic systems using mechanism synthesis theory. While in the plane there are essentially four constrained serial chains (RR, RP, PR and PP) that provide the structure for planar mechanisms and manipulators, in space we find there are 214. Furthermore, while these planar chains can be assembled into seven parallel systems, the spatial chains form hundreds of millions of parallel robotic systems. For this reason a central concern in the development of our synthesis results was that they are useful and extendable by user-collaborators. Our analysis routines were designed for a general system constructed from one or more constrained serial chains. It uses the singular value decomposition to provide a generalized inverse kinematics for these system. The trajectory planning feature using a dual quaternion metric allows the user the flexibility to specify a trajectory that may not lie in the workspace of the constrained robotic system. The routine 157

181 returns an approximation that minimizes this metric. Our synthesis routines focussed on the five degree-of-freedom serial chains that include a spherical wrist. These systems are characterized by a single constraint equation that defines a surface in three dimensional space. Evaluating these equations for a set of specified task positions yielded our design equations. These polynomial systems were solved using sparse matrix resultants for cases with as many as 64 roots, such as the case RPS8. Polynomial homotopy solver POLSYS GLP was developed and used to solve the more complicated systems, for example the case RRS12 has 448, 786 roots and required 45 minutes on 1024 processors of the San Diego Supercomputer Center s Blue Horizon system. Finally, we presented our Synthetica software that integrates task specification, synthesis and analysis of constrained robotics systems. It is designed to allow users to add routines to augment its performance. This research provides the foundation for new results in several different directions: Integrate synthesis routines into CAD environments and develop industry specific synthesis applications. This not only facilitates the following details design but also allows the designers evaluate the design candidate using existing tools such as FEA, dynamics etc. Apply polynomial system solver technology to problems that arise in novel applications such as compliant mechanism synthesis and protein kinematics. Many problems such as protein folding, molecular conformation and compliant 158

182 mechanism synthesis can be characterized using polynomial systems. Obtaining solutions to these polynomial system is a crucial step for these problems. Apply analysis and synthesis techniques to failure recovery for complex robotic systems. In difficult environments, fixing a failed robotic system can be difficult if possible at all. However, by considering this kind of failure into the design stage, many tasks can still be carried out even part of system fails. Develop software tools specialized for micro (MEMS) mechanism design. It is generally time consuming for designers to design, build, test and upgrade a MEMS device. Therefore a design/simulation software specialized for micro mechanism may be useful to speedup the design process. Explore the use of robot analysis and synthesis technique in nanotechnology. Molecular can be viewed as a highly complex robotic system in the sense that atoms resemble links and bonds resemble joints. As a result, the techniques in the mechanism analysis and synthesis may be applied. Recent advances in carbon nanotubes allow possible building complex robotic systems in molecular level. These nano robotic systems can serve as manufacturing center for building more complicated systems. 159

183 Bibliography [1] Bernshtein, D.N., 1975, The Number of Roots of a System of Equations, Functional Anal. Appl, 9(3): [2] Bezout,E., 1779, Theorie generale des equations algebriques, Paris. [3] Bottema, O. and Roth, B., 1979, Theoretical Kinematics, Dover Publications, New York. [4] Burmester, L., 1886, Lehrbuch der Kinematik, Verlag Von Arthur Felix, Leipzig, Germany. [5] Chase, T. R., Erdmn, A. G. and Riley, D., 1981, Synthesis of Six-Bar Linkages Using an Interactive Package, Proc. of the 1981 OSU Applied Mechanism Conference, Kansas City, MO, No.51. [6] Chen, P. and Roth, B., 1969, Design Equations for the Finitely and Infinitesimally Separated Position Synthesis of Binary Links and Combined Link Chains, ASME Journal of Engineering for Industry, 91: [7] Craig, J.,1986, Introduction to Robotics: Mechanics and Control. Addison-Wesley. 160

184 [8] Collins, C. L., McCarthy, J. M., Perez, A. and Su, H.-J., 2002, A Software Architecture for Internet-Aided Design of Linkages, ASME Journal of Computing and Information Science in Engineering, 2: [9] Cox, D., Little, J., and O Shea D., 1998, Using Algebraic Geometry, Springer- Verlag, New York. [10] Denavit, J., and Hartenberg, R.S., 1955, A Kinematic Notation for Lower-pair Mechanisms Based on Matrices, ASME Journal of Applied Mechanics, 22: [11] Dixon, A. L., 1908, The eliminant of three quantics in two independent variables, Proc. of Lond. Math. Society, , [12] Emiris, I.Z. and Mourrain, B., 1999, Matrices in Elimination Theory, Journal of Symbolic Computation, 28:3-43. [13] Erdman, A., and Gustafson, J., 1977, LINCAGES: Linkage INteractive Computer Analysis and Graphically Enhanced Synthesis Packages, Technical Report 77-DET-5, American Society of Mechanical Engineers. [14] Erdman, A. G., and Sandor, G. N., 1997, Mechanism Design: Analysis and Synthesis, 3rd Ed., Prentice-Hall, New Jersey. [15] Garcia, C. B., and Zangwill, W. I., 1977, Global Continuation Methods for Finding all Solutions to Polynomial Systems of Equations in N Variables, Center for Math Studies in Business and Economics Report No.7755, Univ. of Chicago, Chicago, IL. [16] Gao, T., Li, T.Y., and Wu, M., 2003, MixedVol: A Software Package for Mixed Volume Computation, preprint, submitted to ACM Transactions on Math. Sofware. 161

185 [17] Ge, Q. J., and Ravani, B., 1994, Geometric Construction of Bezier Motions, ASME Journal of Mechanical Design, 116: [18] Gegorio, R. D., and Parenti-Castelli, V., 2001, Position Analysis in Analytical Form of the 3-PSP Mechanism, ASME Journal of Mechanical Design, 123(1): [19] Gropp, W., Lusk, E., and Skjellum, A., 2000, Using MPI, Portable Parallel Programming with the Message-Passing Interface, second edition, The MIT Press, Cambridge, MA. [20] Heron Technologies Inc., Watt 1.0 software, [21] Hertz, R. B., and Hughes, P. C., 1998, Kinematic Analysis of a General double- Tripod Parallel Manipulator, Mechanism and Machine Theory, 33(6): [22] Huang, Z., Wang, J., and Fang, Y. F., 2002, Analysis of Instantaneous Motions of Deficient-Rank 3-RPS Parallel Manipulators, Mechanism and Machine Theory, 37: [23] Innocenti, C., 1994, Polynomial Solution of the Spatial Burmester Problem, Mechanism Synthesis and Analysis, DE-Vol. 70, ASME DETC94, Minneapolis, MN. [24] JauSoft Inc., GL4Java [25] Joshi, S. A. and Tsai, L. W., 2002, Jacobian Analysis of Limited-DOF Parallel Manipulators, it Proc. ASME Design Engineering Technical Conferences, Sept.29- Oct.2, Montreal, Canada. [26] Kaufman, R. E., 1978, Mechanism Design by Computer, Machine Design, October, pp

186 [27] Kihonge, J., Vance, J., and Larochelle, P., 2001, Spatial Mechanism Design in Virtual Reality with Networking, Proc. ASME 2001 Design Engineering Technical Conferences, Sept 9-12, Pittsburgh PA. [28] Kraal, J.C. and Vance J.M., 2001, A Virtual Reality Interface for Spherical Mechanism Design, Journal of Engineering Design, 12: ,, [29] Larochelle, P., Dooley, J., Murray, A., McCarthy, J. M., 1993, SPHINX: Software for Synthesizing Spherical 4R Mechanisms, Proc. of the 1993 NSF Design and Manufacturing Systems Conference 1: , Univ. of North Carolina at Charlotte, January [30] Larochelle, P. M., 1998, Spades: Software for Synthesizing Spatial 4C Linkages, CD-ROM Proc. of the ASME DETC 98, paper no. DETC98/Mech-5889, Sept , Atlanta, GA. [31] Lee, E., Mavroidis, C., and Merlet, J.P., 2002, Five Precision Points Synthesis of Spatial RRR Manipulators Using Interval Analysis, Proc. ASME 2002 Design Eng. Tech. Conf., paper no. DETC2002/MECH-34272, Sept. 29-Oct. 2, Montreal, Canada. [32] Lee, E., and Mavroidis, D., 2002, Solving the Geometric Design Problem of Spatial 3R Robot Manipulators Using Polynomial Homotopy Continuation, ASME J. Mechanical Design, 124(4): [33] Lee, E., and Mavroidis, D., 2002, Geometric Design of Spatial PRR Manipulators Using Polynomial Elimination Techniques, Proc. ASME 2002 Design Eng. Tech. Conf., paper no. DETC2002/MECH-34314, Sept. 29-Oct. 2, Montreal, Canada. [34] Leger, C., and Bares, J., 1998, Automated Synthesis and Optimization of Robot Configurations, CD-ROM Proc. of the ASME DETC 98, paper no. DETC98/Mech-5945, Sept.13-16, Atlanta, GA. 163

187 [35] Liao, Q. and McCarthy, J. M., 2001, On the Seven Position Synthesis of a 5-SS Platform Linkage, ASME J. of Mechanical Design, 123(1): [36] Macaulay, F.S., 1902, Some Formulae in Elimination, Proc. London Math. Soc., bf 1(33):3-27 [37] Manocha, D. and Canny, J.F., 1993, MultiPolynomial Resultant Algorithms, J. Symbolic Computation, 15: [38] Manocha, D. and Canny, J.F., 1996, Solving Algebraic Systems using Matrix Computations, ACM Sigsam Bulletin (Invited Paper), 30(4):4-21. [39] Mavroidis, C., Lee, E., and Alam, M., 2001, A New Polynomial Solution to the Geometric Design Problem of Spatial RR Robot Manipulators Using the Denavit- Hartenberg Parameters, ASME J. Mechanical Design, 123(1): [40] McCarthy, J. M., 1990, Introduction to Theoretical Kinematics. The MIT Press, Cambridge, MA. [41] McCarthy, J. M., 2000, Geometric Design of Linkages. Springer-Verlag, New York. [42] Morgan, A. P., 1987, Solving Polynomial Systems Using Continuation for Engineering and Scientific Problems, Prentice-Hall, Englewood Cliffs, NJ.. [43] Morgan, A. P., and Sommese, A. J., 1987, A Homotopy for Solving General Polynomial Systems that Respects m-homogeneous Structures, Appl. Math. Comput., 24: [44] Morgan, A. P., Sommese, A. J., and Wampler, C. W., 1995, A Product- Decomposition Bound for Bezout Numbers, SIAM J. Numer. Anal., 32:

188 [45] Nelson, L., and Erdman, A. G., 1994, Recent Enhancements to the Lincage- 6 Synthesis Package, Including Circuit Rectification, Proc. of the ASME Design Technical Conference, Mechanism Synthesis and Analysis, DE Vol.70, pp [46] Nielsen, J. and Roth, B., 1995, Elimination Methods for Spatial Synthesis Computational Kinematics (eds. J.-P. Merlet and B. Ravani), Kluwer Academic Press, Netherlands. [47] Park, F. C., and Bobrow, J. E., 1995, Geometric Optimization Algorithms for Robot Kinematic Design, Journal of Robotic Systems, 12(6): [48] Perez, A, and McCarthy, J. M., 2000, Dimensional Synthesis of Spatial RR robots, Advances in Robot Kinematics, Piran-Portoroz, Slovenia. [49] Perez A., and McCarthy, J. M., 2002, Dual Quaternion Synthesis of a Parallel 2-TPR Robot, Proc of the Workshop on Fundamental Issues and Future Research Directions for Parallel Mechanisms and Manipulators, October 3-4, 2002, Quebec City, Quebec, CA. [50] Perez, A. and McCarthy, J.M., 2003, Dual Quaternion Synthesis of Constrained Robotic Systems, Journal of Mechanical Design, in press. [51] Perez, A. and McCarthy, J.M., 2003, Dimensional Synthesis of CRR Serial Chains, ASME Design Engineering Technical Conferences, Sept.02-06, Chicago, IL. [52] Perez, A, 2003, Dual Quaternion Synthesis of Constrained Robotic Systems, Ph.D. Dissertation, Department of Mechanical and Aerospace Engineering, University of California, Irvine. [53] Perez A., Su, H.-J., and McCarthy, J.M., 2004, SYNTHETICA 2.0: Software for the Synthesis of Constrained Serial Chains, ASME Design Engineering Technical Conferences, Sept. 28-Oct. 2, Salt Lake City, UT. 165

189 [54] Raghavan, M. and Roth, B., 1995, Solving Polynomial Systems for the Kinematic Analysis and Synthesis of Mechanisms and Robot Manipulators, ASME J. of Mechanical Design, special 50th Anniversary Design Issue, 117: [55] Rubel, A. J., and Kaufman, R. E., 1977, KINSYN 3: A New Human- Engineering System for Interactive Computer Aided Design of Planar Linkages, J. of Engineering for Industry, 99(2). [56] Ruth, D. A., and McCarthy, J. M., 1997, SphinxPC: An Implementation of Four Position Synthesis for Planar and Spherical 4R Linkages, CD-ROM Proc. of the ASME DETC 97, paper no. DETC97/DAC-3860, Sept , Sacramento, CA. [57] Song, S. M., and Waldron, K. J., 1981, Theoretical and Numerical Improvements to an Interactive Linkage Design Program-RECSYN, Proc. of the Seventh Applied Mechanisms Conference, Kansas City, MO. [58] Sturmfels B. and Zelevinsky A., 1992, Multigraded Resultants of Sylvester Type, Journal of Algebra. [59] Su, H., Collins, C. L., and McCarthy, J. M., 2002, An Extensible Java Applet for Linkage Synthesis, ASME Design Engineering Technical Conferences, Sept.29- Oct. 2, Montreal, Canada. [60] Su H.-J., Dietmaier, P. and McCarthy J. M., 2003, Trajectory Planning for Constrained Parallel Manipulators, ASME Journal of Mechanical Design, 125(4): [61] Su, H.-J. and McCarthy J. M., 2003, Kinematic Synthesis of RPS Serial Chains, ASME Design Engineering Technical Conferences, Sept.02-06, Chicago, IL. 166

190 [62] Su, H.-J., Wampler, C. W. and McCarthy J. M., 2004, Geometric Design of Cylindric PRS Serial Chains, ASME Journal of Mechanical Design, 126(1): [63] Su H.-J., McCarthy J. M. and Watson L. T.,2004, Generalized Linear Product Polynomial Continuation and the Computation of Reachable Surfaces, ASME Journal of Information and Computer Sciences in Engineering, in press. [64] Su H.-J., McCarthy J. M., Sosonkina M. and Watson L. T., 2004, POLSYS GLP: A Parallel General Linear Product Homotopy Code for Solving Polynomial Systems of Equations, submitted to ACM Transactions on Mathematical Software. [65] Suh, C. H., and Radcliffe, C. W., 1978, Kinematics and Mechanism Design, John Wiley and Sons, New York. [66] SyMech, software, [67] Sylvester, J. J., 1853, On a theory of syzygetic relations of two rational integral functions, comprising an application to the theory of Sturm s functions, and that of the greatest algebraic common measure, Philosophical Trans., 143: [68] Tsai, L.W., 1973, Design of Open-Loop Chains for Rigid-Body Guidance, Ph.D. dissertation, Stanford University. [69] Tsai, L.W., 2000, Mechanism Design: Enumeration of Kinematic Structures According to Function. CRC Press. [70] Vance, J.M., Larochelle, P. and Dorozhkin, D., 2002, VRSpatial: Designing Spatial Mechanisms Using Virtual Reality, Proc. ASME Design Engineering Technical Conferences, Sept.29-Oct. 2, Montreal, Canada. [71] Verschelde, J., 1999, PHCPACK: A General-Purpose Solver for Polynomial Systems by Homotopy Continuation, ACM Transactions on Mathematical Software, 25(2):

191 [72] Verschelde, J., and Cools, R., 1993, Symbolic Homotopy Construction, Appl. Algebra Engrg. Comm. Comput, 4: [73] Verschelde, J., and Haegemans, A, 1993, The GBQ-Algorithm for Constructing Start Systems of Homotopies for Polynomial Systems, SIAM J. Numer. Anal., 30: [74] Wampler,C., Morgan, A. and Sommese, A., 1990, Numerical Continuation Methods for Solving Polynomial Systems Arising in Kinematics, ASME J. Mechanical Design, 112: [75] Watson, L. T., Billups, S. C., and Morgan, A. P., 1987, Algorithm 652: HOM- PACK: A Suite of Codes for Globally Convergent Homotopy Algorithms, ACM Trans. Math. Software, 13: [76] Watson, L. T., Sosonkina, M., Melville, R. C., Morgan, A. P., and Walker, H. F., 1997, Algorithm 777: HOMPACK90: A Suite of Fortran 90 Codes for Globally Convergent Homotopy Algorithms,, ACM Trans. Math. Software, 23: [77] Wise, S. M., Sommese, A. J., and Watson, L. T., 2000, Algorithm 801:POL- SYS PLP: A Partitioned Linear Product Homotopy Code for Solving Polynomial Systems of Equations,, ACM Trans. Math. Software, 26: [78] Wolbrecht, E., Su, H.-J., Perez, A. and McCarthy, J.M. 2004, Geometric Design Of Symmetric 3-RRS Constrained Parallel Platforms,, submitted to ASME International Mechanical Engineering Congress and Exposition, Anaheim, CA, November [79] Yang, A.T., and Freudenstein, F., 1964, Application of Dual-Number Quaternion Algebra to the Analysis of Spatial Mechanisms, ASME Journal of Applied Mechanics, pp

192 Appendix A POLSYS GLP User s Guide A.1 Compilation and Usage System requirements: Compiler: Software Packages: Systems: Fortran 90, e.g. Portland Group Fortran 90 Compiler MPI-2 Linux, Unix that support MPI-2. File list: Fortran code: main_template.f90, polsys_glp.f90, lapack_glp.f, test_install.f90 Others: REAMDE, INPUT.DAT, OUTPUT.DAT Sample makefile: polsys_glp: pgf90 -c lapack_glp.f pgf90 -c polsys_glp.f90 pgf90 -c main_template.f90 mpif90 lapack_glp.o polsys_glp.o main_template.o -o POLSYS\_GLP rm *.o *.mod 169

193 Note the file extension may need to be changed for some compilers. Usage: mpirun -np 4 POLSYS\_GLP requests four processors to launch POLSYS GLP program. The file INPUT.DAT should be located in the same directory as the program. When the program exits, an OUTPUT.DAT file with solution data is generated. A.2 README File POLSYS_GLP POLSYS_GLP is Fortran 95 parallel code for solving N complex coefficient polynomial systems of equations in N unknowns by a probability-one, globally convergent homotopy method. The package is fully portable across various distributed and parallel computing platforms since it uses the Message Passing Interface (MPI) communication library. POLSYS_GLP consists of two modules: GLOBAL_GLP and POLSYS2. The module GLOBAL_GLP contains the derived data types that define the polynomial system, the system covering, and the start system of the homotopy; the module POLSYS2 contains the actual solver POLSYS_GLP and its internal routines, CHECK_GLP that verifies the input set covering structure, and the routines responsible for root counting, BEZOUT_GLP and SINGSYS_GLP. POLSYS_GLP uses the HOMPACK90 modules HOMOTOPY, HOMPACK90_GLOBAL, and REAL_PRECISION, the HOMPACK90 path tracking routine STEPNX, and numerous BLAS and LAPACK routines. The physical organization into files is: the file polsys_glp.f90 contains 170

194 (in order) REAL_PRECISION, GLOBAL_GLP, POLSYS2, HOMPACK90_GLOBAL, HOMOTOPY, and STEPNX; the file lapack_glp.f contains all the necessary BLAS and LAPACK routines. A sample calling program MAIN_TEMPLATE and a template for a hand-crafted function/jacobian matrix evaluation program TARGET_SYSTEM_USER are contained in the file main_template.f90. All processors execute MAIN_TEMPLATE and read the data file INPUT.DAT. MAIN_TEMPLATE writes the solutions to the file OUTPUT.DAT only by the master processor. The included files INPUT.DAT and OUTPUT.DAT contain sample input and output data for several test polynomial systems. Similar to POLSYS_PLP (Algorithm 801), POLSYS_GLP can batch process multiple systems and tasks from one input file. The file test_install.f90 contains a main program TEST_INSTALL to verify the installation. It reads INPUT.DAT, solves a problem defined there, compares the computed results to known answers, and prints a message indicating whether the installation was apparently successful. To test the package, compile polsys_glp.f90 (as free form Fortran 95 files) and compile lapack_glp.f (as fixed form Fortran 95 files). Then compile main_template.f90 and link to the object files generated previously. Do the same for test_install.f90. TEST_INSTALL provides a simple test of the installation. Note that an implementation of MPI has to be installed to compile POLSYS_GLP. Since both polsys_glp.f90 and main_template.f90 contain MPI primitives, it is advisable to compile these two files with compilers provided by the given MPI implementation. For example, if MPICH ( is installed, use mpif90 for compilation and linking, since it already has all the necessary include and link paths resolved. To run the created executable file <program_name> on four processors of a Beowulf cluster, issue the following command: mpirun -np 4 program_name 171

195 There must be at least two processors to obtain solutions. One processor is the master processor that distributes the homotopy paths and collects the zeros, and the remaining processors track the paths. For the sample input file INPUT.DAT, the results should match those in the sample output file OUTPUT.DAT, although the zeros may be listed in a different order due to compiler/machine differences. For a Beowulf cluster, a sample PBS script file is: #!/bin/csh #PBS -N polsys_glp #PBS -l nodes=4:ppn=2 #PBS -l walltime=10:00:00 # # Edit the next line to reflect your working directory. cd ~ # mpirun -np 4 program_name >& glp.out # End of example script. The modules and external subroutines in polsys_glp.f90 and lapack_glp.f can be stored in module and object libraries and need not be recompiled. The subroutine TARGET_SYSTEM_USER defines the polynomial system and its Jacobian matrix, or a dummy subroutine, and must be supplied on every call to POLSYS_GLP. However, if the user does not wish to change TARGET_SYSTEM_USER, its object code can be stored in the aforementioned object library

196 Inquiries should be directed to Hai-Jun Su J. Michael McCarthy Department of Mechanical and Aerospace Engineering, UCI, Irvine, CA 92697, (949) ; or Layne T. Watson Departments of Computer Science and Mathematics, VPI & SU, Blacksburg, VA 24061, (540) A.3 Mathematica Notebook for Preparing INPUT.DAT A Mathematica package ExportGLP is developed for preparing the file INPUT.DAT. Two functions are included, one is CheckGLP for checking validity of a given GLP structure and the other is ExportGLP for exporting the polynomial system and GLP structure to the file INPUT.DAT. CheckGLP Usage: CheckGLP[PolSys, Partition, SetDeg] where PolSys is a list of polynomials, Partition is the GLP structure and Set- Deg is the degree associated with the GLP structure. CheckGLP returns TRUE if the given GLP start system is valid and FALSE otherwise. ExportGLP Usage 1: ExportGLP[PolSys, Partition, SetDeg] where the parameters are the same as above. A file INPUT.DAT is generated. 173

197 ExportGLP Usage 2: ExportGLP[PolSys] This option will generate 1-homogeneous start system. PolSys is a list of polynomials as above. A file INPUT.DAT is generated. Mathematica Notebook Source Code (* :Title: Prepressing tools for POLSYS_GLP *) (* :Author: Hai-Jun Su and J.Michael McCarthy [email protected], [email protected] Addess: Laboratory for the Analysis and Synthesis of Spatial Movement University of California at Irvine Irvine, CA Tel: (949) Web: *) (* :Version: Mathematica 5.0 *) (* :Keywords: polynomial homotopy solver, POLSYS_GLP, generalized linear product *) (* :History: Version 1.0 by Hai-Jun Su, *) (* :Summary: This package is for generating INPUT.DAT file for POLSYS_GLP a polynomial homotopy solver developed at Univeristy of California, Irvine. *) BeginPackage["Homotopy ExportGLP "] CheckGLP::usage = "CheckGLP[PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ] check if the \ validity of the given partition." ExportGLP::usage = "ExportGLP exports the polynomial system to a data file. \n Warning: the calling notebook must have a name. \n Possible Options: \n [PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ, FileName_?StringQ]: full options \n [PolSys_?ListQ]: 1 homogenous start system, filename = INPUT.DAT \n [PolSys_?ListQ, Partition_?ListQ]: All set degree are 1, filename = INPUT.DAT \n [PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ]: filename = INPUT.DAT.\n [PolSys_?ListQ, Partition_?ListQ, FileName_?StringQ]: All set degree are 1. \n " 174

198 Begin[" Private "] (********************************** Interface for POLSYS_GLP **********************) CheckGLP[PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ] := Module[{NN = Length[PolSys], \ StartSystem, ValidFlag, If[Length[Partition]? NN Length[SetDeg]? NN, Print["\nLength[PolSys]!=Length[Partition] or Length[PolSys]!= Length[SetDeg]"]; Return[False]; ]; ValidFlag = Table[CheckGLPOneEqn[PolSys[[i]], Partition[[i]], SetDeg[[i]]], {i, 1, NN]; Print[ValidFlag]; If[MemberQ[ValidFlag, False], Return[False], Return[True]] ] CheckGLPOneEqn[Pol_, Partition_?ListQ, SetDeg_?ListQ] := Module[{StartSystem, MonListAll, MonListPol, PL, ValidFlag, If[Length[Partition]? Length[SetDeg], Print["Length[PolSys]!=Length[SetDeg]"]; Return[False]; ]; StartSystem = 1; Do[ Do[ Coef = Table[Random[Real, {-1, 1, 20], {k, Length[Partition[[i]]]]; StartSystem = StartSystem*(Coef.Partition[[i]] - 1);, {j, 1, SetDeg[[i]]], {i, 1, Length[Partition] ]; StartSystem = Expand[StartSystem]; MonListAll = Table[StartSystem[[i]], {i, Length[StartSystem]] /. {_Real -> 1; PL = N[Expand[Pol], 20]; MonListPol = Table[PL[[i]], {i, Length[PL]] /. {_Real ->1, _Complex -> 1; ValidFlag = Table[MemberQ[MonListAll, MonListPol[[i]]], {i, Length[MonListPol]]; If[MemberQ[ValidFlag, False], Return[False], Return[True]] ] ExportGLP[PolSys_?ListQ] := ExportGLP[PolSys, "INPUT.DAT"]; ExportGLP[PolSys_?ListQ, FileName_?StringQ ] := Module[{Partition, SetDeg, Vars, PL, maxdeg, Vars = Variables[PolSys]; Partition = Table[{Vars, {i, Length[PolSys]]; PL = Expand[PolSys]; 175

199 maxdeg = Table[Max[Table[Sum[Exponent[PL[[k, i]], Vars[[j]]], {j, 1, Length[Vars]], {i, 1, Length[PL[[1]]]]], {k, 1, Length[PL]]; SetDeg = Table[{maxDeg[[i]], {i, 1, Length[Partition]]; ExportGLP[PolSys, Partition, SetDeg, FileName];] ExportGLP[PolSys_?ListQ, Partition_?ListQ] := ExportGLP[PolSys, Partition, "INPUT.DAT"]; ExportGLP[PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ] := ExportGLP[PolSys, Partition, SetDeg, "INPUT.DAT"]; ExportGLP[PolSys_?ListQ, Partition_?ListQ, FileName_?StringQ] := Module[{SetDeg, SetDeg = Table[Table[1, {j, 1, Length[Partition[[i]]]], {i, 1, Length[Partition]]; Print[SetDeg]; ExportGLP[PolSys, Partition, SetDeg, "INPUT.DAT"];] ExportGLP[PolSys_?ListQ, Partition_?ListQ, SetDeg_?ListQ, FileName_?StringQ] := Module[{OldDir, outputfile, vars, NumEQ, SYSPARTITION, PROBLEM, TITLE, TRACKTOL, FINALTOL, SINGTOL, SSPAR5, NUMRR, AllTerms, CoeffAllTerms, TotalDEGs, TOTDG, MAXT, OldDir = Directory[]; CurrentDir = ToFileName[Extract["FileName" /. NotebookInformation[EvaluationNotebook[]], {1, FrontEnd FileName]]; SetDirectory[CurrentDir]; outputfile = OpenWrite[FileName]; vars = Variables[PolSys]; NumEQ = Length[PolSys]; PROBLEM = "&PROBLEM NEW_PROBLEM =.TRUE. \n"; TITLE = "TITLE = This data file is generated by Mathematica and intended for use POLSYS_GLP. \n"; TRACKTOL = "TRACKTOL = 1.D-04\n"; FINALTOL = "FINALTOL = 1.D-12\n"; SINGTOL = "SINGTOL = 0.0\n"; SSPAR5 = "SSPAR(5) = 1.D+00\n"; NUMRR = 1; SYSPARTITION = "&SYSGLPSET ROOT_COUNT_ONLY =.FALSE.\n"; AllTerms = Table[Table[PolSys[[i, j]], {j, Length[PolSys[[i]]]], {i, Length[PolSys]]; CoeffAllTerms = AllTerms /. Table[vars[[i]] -> 1, {i, Length[vars]]; TotalDEGs = Table[Max[Table[Sum[Exponent[AllTerms[[i, j]], vars[[k]]], {k, Length[vars]], {j, Length[AllTerms[[i]]]]], {i, Length[AllTerms]]; TOTDG = Product[TotalDEGs[[i]], {i, Length[TotalDEGs]]; MAXT = Max[Table[Length[PolSys[[i]]], {i, Length[PolSys]]]; WriteString[outputFile, PROBLEM]; WriteString[outputFile, TITLE]; WriteString[outputFile, "\n"]; WriteString[outputFile, TRACKTOL]; 176

200 WriteString[outputFile, FINALTOL]; WriteString[outputFile, SINGTOL]; WriteString[outputFile, SSPAR5]; WriteString[outputFile, "NUMRR = ", NUMRR, "\n"]; WriteString[outputFile, "N = ", NumEQ, "\n"]; WriteString[outputFile, "\n"]; Do[ WriteString[outputFile, "NUM_TERMS(", i, ") = ", Length[AllTerms[[i]]], "\n"]; Do[ Do[WriteString[outputFile, " DEG(", i, ",", j, ",", k, ") = ", Exponent[AllTerms[[i, j]], vars[[k]]], "\n"], {k, Length[vars]]; WriteString[outputFile, " COEF(", i, ", ", j, ") = (", FortranForm[Re[N[CoeffAllTerms[[i,j]]]]], ", ", FortranForm[Im[N[CoeffAllTerms[[i, j]]]]], ")", "\n"], {j, Length[AllTerms[[i]]]]; WriteString[outputFile, "\n"];, {i, Length[AllTerms]]; WriteString[outputFile, "/\n"]; WriteString[outputFile, SYSPARTITION]; Do[WriteString[outputFile, "P(", i, ") = ", Partition[[i]], " \n"], {i, 1, Length[Partition]]; Do[WriteString[outputFile, "DG(", i, ") = ", SetDeg[[i]], " \n"], {i, 1, Length[SetDeg]]; WriteString[outputFile, "\n"]; Do[WriteString[outputFile, "NUM_SETS(", i, ") = ", Length[Partition[[i]]], "\n"]; Do[WriteString[outputFile, " NUM_INDICES(", i, ",", j, ") = ", Length[Partition[[i, j]]], " SET_DEG(", i, ",", j, ") = ", SetDeg[[i, j]], "\n"]; Do[WriteString[outputFile, " INDEX(", i, ",", j, ",", k, ") = ", (Position[vars, Partition[[i, j, k]]])[[1, 1]], "\n"], {k, Length[Partition[[i, j]]]];, {j, Length[Partition[[i]]]];, {i, 1, NumEQ]; WriteString[outputFile, "/\n"]; Print["FILE = ", FileName, "\nnumber of Equations = ", NumEQ, "\nnumber of Variables = ", Length[vars], " ", vars, "\ntotal Degree = ", TOTDG, 177

201 "\nmaximun Number of Terms = ", MAXT, "\n PARTITION = \n", Partition]; Close[outputFile]; SetDirectory[OldDir]; ] (*End of Module*) End[] EndPackage[] A.4 Sample INPUT.DAT and OUTPUT.DAT Here we use the example of CS6 design problem in Table 5.4 to show the result of POL- SYS GLP. Interested readers can compare the solutions in the file OUTPUT.DAT with Table 5.5. INPUT.DAT &PROBLEM NEW_PROBLEM =.TRUE. TITLE = CS6 DESIGN PROBLEM: FIVE QUADRICS, NO SOLUTIONS AT INFINITY, 26 REAL SOLUTIONS. TRACKTOL = 1.0D-04 FINALTOL = 1.0D-14 SINGTOL = 0.0D0 SSPAR(5) = 1.0D0 NUMRR = 1 N = 5 DEG=40000*0 NUM_TERMS(1) = 18 DEG(1,1,1) = 0 DEG(1,1,2) = 0 DEG(1,1,3) = 0 DEG(1,1,4) = 0 DEG(1,1,5) = 0 COEF(1,1) = ( E-02, E+00) 178

202 DEG(1,2,1) = 1 DEG(1,2,2) = 0 DEG(1,2,3) = 0 DEG(1,2,4) = 0 DEG(1,2,5) = 0 COEF(1,2) = ( , 0) DEG(1,3,1) = 0 DEG(1,3,2) = 1 DEG(1,3,3) = 0 DEG(1,3,4) = 0 DEG(1,3,5) = 0 COEF(1,3) = ( , 0) DEG(1,4,1) = 0 DEG(1,4,2) = 0 DEG(1,4,3) = 1 DEG(1,4,4) = 0 DEG(1,4,5) = 0 COEF(1,4) = ( , 0) DEG(1,5,1) = 1 DEG(1,5,2) = 0 DEG(1,5,3) = 1 DEG(1,5,4) = 0 DEG(1,5,5) = 0 COEF(1,5) = ( , 0) DEG(1,6,1) = 0 DEG(1,6,2) = 1 DEG(1,6,3) = 1 DEG(1,6,4) = 0 DEG(1,6,5) = 0 COEF(1,6) = ( , 0) 179

203 DEG(1,7,1) = 0 DEG(1,7,2) = 0 DEG(1,7,3) = 2 DEG(1,7,4) = 0 DEG(1,7,5) = 0 COEF(1,7) = ( , 0) DEG(1,8,1) = 0 DEG(1,8,2) = 0 DEG(1,8,3) = 0 DEG(1,8,4) = 1 DEG(1,8,5) = 0 COEF(1,8) = ( , 0) DEG(1,9,1) = 1 DEG(1,9,2) = 0 DEG(1,9,3) = 0 DEG(1,9,4) = 1 DEG(1,9,5) = 0 COEF(1,9) = ( , 0) DEG(1,10,1) = 0 DEG(1,10,2) = 1 DEG(1,10,3) = 0 DEG(1,10,4) = 1 DEG(1,10,5) = 0 COEF(1,10) = ( , 0) DEG(1,11,1) = 0 DEG(1,11,2) = 0 DEG(1,11,3) = 1 DEG(1,11,4) = 1 DEG(1,11,5) = 0 COEF(1,11) = ( , 0) 180

204 DEG(1,12,1) = 0 DEG(1,12,2) = 0 DEG(1,12,3) = 0 DEG(1,12,4) = 2 DEG(1,12,5) = 0 COEF(1,12) = ( , 0) DEG(1,13,1) = 0 DEG(1,13,2) = 0 DEG(1,13,3) = 0 DEG(1,13,4) = 0 DEG(1,13,5) = 1 COEF(1,13) = ( , 0) DEG(1,14,1) = 1 DEG(1,14,2) = 0 DEG(1,14,3) = 0 DEG(1,14,4) = 0 DEG(1,14,5) = 1 COEF(1,14) = ( , 0) DEG(1,15,1) = 0 DEG(1,15,2) = 1 DEG(1,15,3) = 0 DEG(1,15,4) = 0 DEG(1,15,5) = 1 COEF(1,15) = ( , 0) DEG(1,16,1) = 0 DEG(1,16,2) = 0 DEG(1,16,3) = 1 DEG(1,16,4) = 0 DEG(1,16,5) = 1 COEF(1,16) = ( , 0) 181

205 DEG(1,17,1) = 0 DEG(1,17,2) = 0 DEG(1,17,3) = 0 DEG(1,17,4) = 1 DEG(1,17,5) = 1 COEF(1,17) = ( , 0) DEG(1,18,1) = 0 DEG(1,18,2) = 0 DEG(1,18,3) = 0 DEG(1,18,4) = 0 DEG(1,18,5) = 2 COEF(1,18) = ( , 0) NUM_TERMS(2) = 18 DEG(2,1,1) = 0 DEG(2,1,2) = 0 DEG(2,1,3) = 0 DEG(2,1,4) = 0 DEG(2,1,5) = 0 COEF(2,1) = ( , 0) DEG(2,2,1) = 1 DEG(2,2,2) = 0 DEG(2,2,3) = 0 DEG(2,2,4) = 0 DEG(2,2,5) = 0 COEF(2,2) = ( , 0) DEG(2,3,1) = 0 DEG(2,3,2) = 1 DEG(2,3,3) = 0 DEG(2,3,4) = 0 182

206 DEG(2,3,5) = 0 COEF(2,3) = ( , 0) DEG(2,4,1) = 0 DEG(2,4,2) = 0 DEG(2,4,3) = 1 DEG(2,4,4) = 0 DEG(2,4,5) = 0 COEF(2,4) = ( , 0) DEG(2,5,1) = 1 DEG(2,5,2) = 0 DEG(2,5,3) = 1 DEG(2,5,4) = 0 DEG(2,5,5) = 0 COEF(2,5) = ( , 0) DEG(2,6,1) = 0 DEG(2,6,2) = 1 DEG(2,6,3) = 1 DEG(2,6,4) = 0 DEG(2,6,5) = 0 COEF(2,6) = ( , 0) DEG(2,7,1) = 0 DEG(2,7,2) = 0 DEG(2,7,3) = 2 DEG(2,7,4) = 0 DEG(2,7,5) = 0 COEF(2,7) = ( , 0) DEG(2,8,1) = 0 DEG(2,8,2) = 0 DEG(2,8,3) = 0 DEG(2,8,4) = 1 183

207 DEG(2,8,5) = 0 COEF(2,8) = ( , 0) DEG(2,9,1) = 1 DEG(2,9,2) = 0 DEG(2,9,3) = 0 DEG(2,9,4) = 1 DEG(2,9,5) = 0 COEF(2,9) = ( , 0) DEG(2,10,1) = 0 DEG(2,10,2) = 1 DEG(2,10,3) = 0 DEG(2,10,4) = 1 DEG(2,10,5) = 0 COEF(2,10) = ( , 0) DEG(2,11,1) = 0 DEG(2,11,2) = 0 DEG(2,11,3) = 1 DEG(2,11,4) = 1 DEG(2,11,5) = 0 COEF(2,11) = ( , 0) DEG(2,12,1) = 0 DEG(2,12,2) = 0 DEG(2,12,3) = 0 DEG(2,12,4) = 2 DEG(2,12,5) = 0 COEF(2,12) = ( , 0) DEG(2,13,1) = 0 DEG(2,13,2) = 0 DEG(2,13,3) = 0 DEG(2,13,4) = 0 184

208 DEG(2,13,5) = 1 COEF(2,13) = ( , 0) DEG(2,14,1) = 1 DEG(2,14,2) = 0 DEG(2,14,3) = 0 DEG(2,14,4) = 0 DEG(2,14,5) = 1 COEF(2,14) = ( , 0) DEG(2,15,1) = 0 DEG(2,15,2) = 1 DEG(2,15,3) = 0 DEG(2,15,4) = 0 DEG(2,15,5) = 1 COEF(2,15) = ( , 0) DEG(2,16,1) = 0 DEG(2,16,2) = 0 DEG(2,16,3) = 1 DEG(2,16,4) = 0 DEG(2,16,5) = 1 COEF(2,16) = ( , 0) DEG(2,17,1) = 0 DEG(2,17,2) = 0 DEG(2,17,3) = 0 DEG(2,17,4) = 1 DEG(2,17,5) = 1 COEF(2,17) = ( , 0) DEG(2,18,1) = 0 DEG(2,18,2) = 0 DEG(2,18,3) = 0 DEG(2,18,4) = 0 185

209 DEG(2,18,5) = 2 COEF(2,18) = ( , 0) NUM_TERMS(3) = 18 DEG(3,1,1) = 0 DEG(3,1,2) = 0 DEG(3,1,3) = 0 DEG(3,1,4) = 0 DEG(3,1,5) = 0 COEF(3,1) = ( , 0) DEG(3,2,1) = 1 DEG(3,2,2) = 0 DEG(3,2,3) = 0 DEG(3,2,4) = 0 DEG(3,2,5) = 0 COEF(3,2) = ( , 0) DEG(3,3,1) = 0 DEG(3,3,2) = 1 DEG(3,3,3) = 0 DEG(3,3,4) = 0 DEG(3,3,5) = 0 COEF(3,3) = ( , 0) DEG(3,4,1) = 0 DEG(3,4,2) = 0 DEG(3,4,3) = 1 DEG(3,4,4) = 0 DEG(3,4,5) = 0 COEF(3,4) = ( , 0) DEG(3,5,1) = 1 DEG(3,5,2) = 0 186

210 DEG(3,5,3) = 1 DEG(3,5,4) = 0 DEG(3,5,5) = 0 COEF(3,5) = ( , 0) DEG(3,6,1) = 0 DEG(3,6,2) = 1 DEG(3,6,3) = 1 DEG(3,6,4) = 0 DEG(3,6,5) = 0 COEF(3,6) = ( , 0) DEG(3,7,1) = 0 DEG(3,7,2) = 0 DEG(3,7,3) = 2 DEG(3,7,4) = 0 DEG(3,7,5) = 0 COEF(3,7) = ( , 0) DEG(3,8,1) = 0 DEG(3,8,2) = 0 DEG(3,8,3) = 0 DEG(3,8,4) = 1 DEG(3,8,5) = 0 COEF(3,8) = ( , 0) DEG(3,9,1) = 1 DEG(3,9,2) = 0 DEG(3,9,3) = 0 DEG(3,9,4) = 1 DEG(3,9,5) = 0 COEF(3,9) = ( , 0) DEG(3,10,1) = 0 DEG(3,10,2) = 1 187

211 DEG(3,10,3) = 0 DEG(3,10,4) = 1 DEG(3,10,5) = 0 COEF(3,10) = ( , 0) DEG(3,11,1) = 0 DEG(3,11,2) = 0 DEG(3,11,3) = 1 DEG(3,11,4) = 1 DEG(3,11,5) = 0 COEF(3,11) = ( , 0) DEG(3,12,1) = 0 DEG(3,12,2) = 0 DEG(3,12,3) = 0 DEG(3,12,4) = 2 DEG(3,12,5) = 0 COEF(3,12) = ( , 0) DEG(3,13,1) = 0 DEG(3,13,2) = 0 DEG(3,13,3) = 0 DEG(3,13,4) = 0 DEG(3,13,5) = 1 COEF(3,13) = ( , 0) DEG(3,14,1) = 1 DEG(3,14,2) = 0 DEG(3,14,3) = 0 DEG(3,14,4) = 0 DEG(3,14,5) = 1 COEF(3,14) = ( , 0) DEG(3,15,1) = 0 DEG(3,15,2) = 1 188

212 DEG(3,15,3) = 0 DEG(3,15,4) = 0 DEG(3,15,5) = 1 COEF(3,15) = ( , 0) DEG(3,16,1) = 0 DEG(3,16,2) = 0 DEG(3,16,3) = 1 DEG(3,16,4) = 0 DEG(3,16,5) = 1 COEF(3,16) = ( , 0) DEG(3,17,1) = 0 DEG(3,17,2) = 0 DEG(3,17,3) = 0 DEG(3,17,4) = 1 DEG(3,17,5) = 1 COEF(3,17) = ( , 0) DEG(3,18,1) = 0 DEG(3,18,2) = 0 DEG(3,18,3) = 0 DEG(3,18,4) = 0 DEG(3,18,5) = 2 COEF(3,18) = ( , 0) NUM_TERMS(4) = 18 DEG(4,1,1) = 0 DEG(4,1,2) = 0 DEG(4,1,3) = 0 DEG(4,1,4) = 0 DEG(4,1,5) = 0 COEF(4,1) = ( , 0) 189

213 DEG(4,2,1) = 1 DEG(4,2,2) = 0 DEG(4,2,3) = 0 DEG(4,2,4) = 0 DEG(4,2,5) = 0 COEF(4,2) = ( , 0) DEG(4,3,1) = 0 DEG(4,3,2) = 1 DEG(4,3,3) = 0 DEG(4,3,4) = 0 DEG(4,3,5) = 0 COEF(4,3) = ( , 0) DEG(4,4,1) = 0 DEG(4,4,2) = 0 DEG(4,4,3) = 1 DEG(4,4,4) = 0 DEG(4,4,5) = 0 COEF(4,4) = ( , 0) DEG(4,5,1) = 1 DEG(4,5,2) = 0 DEG(4,5,3) = 1 DEG(4,5,4) = 0 DEG(4,5,5) = 0 COEF(4,5) = ( , 0) DEG(4,6,1) = 0 DEG(4,6,2) = 1 DEG(4,6,3) = 1 DEG(4,6,4) = 0 DEG(4,6,5) = 0 COEF(4,6) = ( , 0) 190

214 DEG(4,7,1) = 0 DEG(4,7,2) = 0 DEG(4,7,3) = 2 DEG(4,7,4) = 0 DEG(4,7,5) = 0 COEF(4,7) = ( , 0) DEG(4,8,1) = 0 DEG(4,8,2) = 0 DEG(4,8,3) = 0 DEG(4,8,4) = 1 DEG(4,8,5) = 0 COEF(4,8) = ( , 0) DEG(4,9,1) = 1 DEG(4,9,2) = 0 DEG(4,9,3) = 0 DEG(4,9,4) = 1 DEG(4,9,5) = 0 COEF(4,9) = ( , 0) DEG(4,10,1) = 0 DEG(4,10,2) = 1 DEG(4,10,3) = 0 DEG(4,10,4) = 1 DEG(4,10,5) = 0 COEF(4,10) = ( , 0) DEG(4,11,1) = 0 DEG(4,11,2) = 0 DEG(4,11,3) = 1 DEG(4,11,4) = 1 DEG(4,11,5) = 0 COEF(4,11) = ( , 0) 191

215 DEG(4,12,1) = 0 DEG(4,12,2) = 0 DEG(4,12,3) = 0 DEG(4,12,4) = 2 DEG(4,12,5) = 0 COEF(4,12) = ( , 0) DEG(4,13,1) = 0 DEG(4,13,2) = 0 DEG(4,13,3) = 0 DEG(4,13,4) = 0 DEG(4,13,5) = 1 COEF(4,13) = ( , 0) DEG(4,14,1) = 1 DEG(4,14,2) = 0 DEG(4,14,3) = 0 DEG(4,14,4) = 0 DEG(4,14,5) = 1 COEF(4,14) = ( , 0) DEG(4,15,1) = 0 DEG(4,15,2) = 1 DEG(4,15,3) = 0 DEG(4,15,4) = 0 DEG(4,15,5) = 1 COEF(4,15) = ( , 0) DEG(4,16,1) = 0 DEG(4,16,2) = 0 DEG(4,16,3) = 1 DEG(4,16,4) = 0 DEG(4,16,5) = 1 COEF(4,16) = ( , 0) 192

216 DEG(4,17,1) = 0 DEG(4,17,2) = 0 DEG(4,17,3) = 0 DEG(4,17,4) = 1 DEG(4,17,5) = 1 COEF(4,17) = ( , 0) DEG(4,18,1) = 0 DEG(4,18,2) = 0 DEG(4,18,3) = 0 DEG(4,18,4) = 0 DEG(4,18,5) = 2 COEF(4,18) = ( , 0) NUM_TERMS(5) = 18 DEG(5,1,1) = 0 DEG(5,1,2) = 0 DEG(5,1,3) = 0 DEG(5,1,4) = 0 DEG(5,1,5) = 0 COEF(5,1) = ( , 0) DEG(5,2,1) = 1 DEG(5,2,2) = 0 DEG(5,2,3) = 0 DEG(5,2,4) = 0 DEG(5,2,5) = 0 COEF(5,2) = ( , 0) DEG(5,3,1) = 0 DEG(5,3,2) = 1 DEG(5,3,3) = 0 DEG(5,3,4) = 0 193

217 DEG(5,3,5) = 0 COEF(5,3) = ( , 0) DEG(5,4,1) = 0 DEG(5,4,2) = 0 DEG(5,4,3) = 1 DEG(5,4,4) = 0 DEG(5,4,5) = 0 COEF(5,4) = ( , 0) DEG(5,5,1) = 1 DEG(5,5,2) = 0 DEG(5,5,3) = 1 DEG(5,5,4) = 0 DEG(5,5,5) = 0 COEF(5,5) = ( , 0) DEG(5,6,1) = 0 DEG(5,6,2) = 1 DEG(5,6,3) = 1 DEG(5,6,4) = 0 DEG(5,6,5) = 0 COEF(5,6) = ( , 0) DEG(5,7,1) = 0 DEG(5,7,2) = 0 DEG(5,7,3) = 2 DEG(5,7,4) = 0 DEG(5,7,5) = 0 COEF(5,7) = ( , 0) DEG(5,8,1) = 0 DEG(5,8,2) = 0 DEG(5,8,3) = 0 DEG(5,8,4) = 1 194

218 DEG(5,8,5) = 0 COEF(5,8) = ( , 0) DEG(5,9,1) = 1 DEG(5,9,2) = 0 DEG(5,9,3) = 0 DEG(5,9,4) = 1 DEG(5,9,5) = 0 COEF(5,9) = ( , 0) DEG(5,10,1) = 0 DEG(5,10,2) = 1 DEG(5,10,3) = 0 DEG(5,10,4) = 1 DEG(5,10,5) = 0 COEF(5,10) = ( , 0) DEG(5,11,1) = 0 DEG(5,11,2) = 0 DEG(5,11,3) = 1 DEG(5,11,4) = 1 DEG(5,11,5) = 0 COEF(5,11) = ( , 0) DEG(5,12,1) = 0 DEG(5,12,2) = 0 DEG(5,12,3) = 0 DEG(5,12,4) = 2 DEG(5,12,5) = 0 COEF(5,12) = ( , 0) DEG(5,13,1) = 0 DEG(5,13,2) = 0 DEG(5,13,3) = 0 DEG(5,13,4) = 0 195

219 DEG(5,13,5) = 1 COEF(5,13) = ( , 0) DEG(5,14,1) = 1 DEG(5,14,2) = 0 DEG(5,14,3) = 0 DEG(5,14,4) = 0 DEG(5,14,5) = 1 COEF(5,14) = ( , 0) DEG(5,15,1) = 0 DEG(5,15,2) = 1 DEG(5,15,3) = 0 DEG(5,15,4) = 0 DEG(5,15,5) = 1 COEF(5,15) = ( , 0) DEG(5,16,1) = 0 DEG(5,16,2) = 0 DEG(5,16,3) = 1 DEG(5,16,4) = 0 DEG(5,16,5) = 1 COEF(5,16) = ( , 0) DEG(5,17,1) = 0 DEG(5,17,2) = 0 DEG(5,17,3) = 0 DEG(5,17,4) = 1 DEG(5,17,5) = 1 COEF(5,17) = ( , 0) DEG(5,18,1) = 0 DEG(5,18,2) = 0 DEG(5,18,3) = 0 DEG(5,18,4) = 0 196

220 DEG(5,18,5) = 2 COEF(5,18) = ( , 0) / &SYSGLPSET ROOT_COUNT_ONLY =.FALSE. P(1) = {{u, v, x, y, z, {x, y, z P(2) = {{u, v, x, y, z, {x, y, z P(3) = {{u, v, x, y, z, {x, y, z P(4) = {{u, v, x, y, z, {x, y, z P(5) = {{u, v, x, y, z, {x, y, z DG(1) = {1, 1 DG(2) = {1, 1 DG(3) = {1, 1 DG(4) = {1, 1 DG(5) = {1, 1 NUM_SETS(1) = 2 NUM_INDICES(1,1) = 5 SET_DEG(1,1) = 1 INDEX(1,1,1) = 1 INDEX(1,1,2) = 2 INDEX(1,1,3) = 3 INDEX(1,1,4) = 4 INDEX(1,1,5) = 5 NUM_INDICES(1,2) = 3 SET_DEG(1,2) = 1 INDEX(1,2,1) = 3 INDEX(1,2,2) = 4 INDEX(1,2,3) = 5 NUM_SETS(2) = 2 NUM_INDICES(2,1) = 5 SET_DEG(2,1) = 1 INDEX(2,1,1) = 1 INDEX(2,1,2) = 2 197

221 INDEX(2,1,3) = 3 INDEX(2,1,4) = 4 INDEX(2,1,5) = 5 NUM_INDICES(2,2) = 3 SET_DEG(2,2) = 1 INDEX(2,2,1) = 3 INDEX(2,2,2) = 4 INDEX(2,2,3) = 5 NUM_SETS(3) = 2 NUM_INDICES(3,1) = 5 SET_DEG(3,1) = 1 INDEX(3,1,1) = 1 INDEX(3,1,2) = 2 INDEX(3,1,3) = 3 INDEX(3,1,4) = 4 INDEX(3,1,5) = 5 NUM_INDICES(3,2) = 3 SET_DEG(3,2) = 1 INDEX(3,2,1) = 3 INDEX(3,2,2) = 4 INDEX(3,2,3) = 5 NUM_SETS(4) = 2 NUM_INDICES(4,1) = 5 SET_DEG(4,1) = 1 INDEX(4,1,1) = 1 INDEX(4,1,2) = 2 INDEX(4,1,3) = 3 INDEX(4,1,4) = 4 INDEX(4,1,5) = 5 NUM_INDICES(4,2) = 3 SET_DEG(4,2) = 1 INDEX(4,2,1) = 3 INDEX(4,2,2) = 4 INDEX(4,2,3) = 5 NUM_SETS(5) = 2 198

222 NUM_INDICES(5,1) = 5 SET_DEG(5,1) = 1 INDEX(5,1,1) = 1 INDEX(5,1,2) = 2 INDEX(5,1,3) = 3 INDEX(5,1,4) = 4 INDEX(5,1,5) = 5 NUM_INDICES(5,2) = 3 SET_DEG(5,2) = 1 INDEX(5,2,1) = 3 INDEX(5,2,2) = 4 INDEX(5,2,3) = 5 / OUTPUT.DAT CS6 DESIGN PROBLEM: FIVE QUADRICS, NO SOLUTIONS AT INFINITY, 26 REAL SOLUTIONS. TRACKTOL, FINALTOL = E E-14 SINGTOL (0 SETS DEFAULT) = E-08 SSPAR(5) (0 SETS DEFAULT) = E+00 NUMBER OF EQUATIONS = 5 ===== PROCESSOR 1 TRACKED 0 PATHS IN 7.844E-01 secs ===== ===== PROCESSOR 2 TRACKED 26 PATHS IN 7.843E-01 secs ===== PATH NUMBER = 1 ARCLEN = E+01 NFE = 109 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E

223 FINITE REAL SOLUTION X( 1) = ( E+00, E-17) X( 2) = ( E-01, E-17) X( 3) = ( E+00, E-17) X( 4) = ( E+00, E-16) X( 5) = ( E+01, E-16) X( 6) = ( E+00, E-18) PATH NUMBER = 2 ARCLEN = E+00 NFE = 64 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-18 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-16) X( 3) = ( E+01, E-15) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-16) X( 6) = ( E-01, E-17) PATH NUMBER = 3 ARCLEN = E+01 NFE =

224 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-18 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-17) X( 3) = ( E+00, E-17) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-17) X( 6) = ( E-01, E-17) PATH NUMBER = 4 ARCLEN = E+00 NFE = 78 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E+00, E-14) X( 2) = ( E+00, E-14) X( 3) = ( E+00, E-14) X( 4) = ( E-01, E-14) X( 5) = ( E+00, E-13) X( 6) = ( E-01, E-15) PATH NUMBER = 5 201

225 ARCLEN = E+00 NFE = 82 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E+00, E-15) X( 2) = ( E+00, E-15) X( 3) = ( E+00, E-15) X( 4) = ( E+00, E-15) X( 5) = ( E+00, E-15) X( 6) = ( E-01, E-16) PATH NUMBER = 6 ARCLEN = E+01 NFE = 120 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E+00, E-16) X( 2) = ( E+00, E-16) X( 3) = ( E+00, E-17) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-16) X( 6) = ( E+00, E-16) 202

226 PATH NUMBER = 7 ARCLEN = E+01 NFE = 186 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-16) X( 3) = ( E+00, E-16) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-16) X( 6) = ( E+00, E-15) PATH NUMBER = 8 ARCLEN = E+01 NFE = 164 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E-01, E-18) X( 2) = ( E+00, E-16) X( 3) = ( E+00, E-17) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-16) 203

227 X( 6) = ( E-01, E-18) PATH NUMBER = 9 ARCLEN = E+01 NFE = 124 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-18 FINITE REAL SOLUTION X( 1) = ( E+00, E-17) X( 2) = ( E+00, E-16) X( 3) = ( E+01, E-16) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-17) X( 6) = ( E-01, E-18) PATH NUMBER = 10 ARCLEN = E+00 NFE = 83 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E+00, E-13) X( 2) = ( E+00, E-14) X( 3) = ( E+00, E-13) X( 4) = ( E+01, E-13) 204

228 X( 5) = ( E+00, E-14) X( 6) = ( E-02, E-15) PATH NUMBER = 11 ARCLEN = E+00 NFE = 81 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-15) X( 2) = ( E-01, E-15) X( 3) = ( E-02, E-16) X( 4) = ( E+00, E-15) X( 5) = ( E+00, E-15) X( 6) = ( E-01, E-15) PATH NUMBER = 12 ARCLEN = E+00 NFE = 89 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-15) X( 2) = ( E-01, E-14) 205

229 X( 3) = ( E-02, E-16) X( 4) = ( E+00, E-14) X( 5) = ( E+00, E-15) X( 6) = ( E-01, E-15) PATH NUMBER = 13 ARCLEN = E+00 NFE = 77 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E-01, E-17) X( 3) = ( E+00, E-18) X( 4) = ( E-01, E-17) X( 5) = ( E+00, E-17) X( 6) = ( E-01, E-18) PATH NUMBER = 14 ARCLEN = E+01 NFE = 95 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION 206

230 X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-17) X( 3) = ( E+00, E-16) X( 4) = ( E-01, E-17) X( 5) = ( E+00, E-16) X( 6) = ( E+00, E-15) PATH NUMBER = 15 ARCLEN = E+01 NFE = 111 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-16 FINITE REAL SOLUTION X( 1) = ( E+00, E-16) X( 2) = ( E+00, E-15) X( 3) = ( E+00, E-16) X( 4) = ( E+00, E-16) X( 5) = ( E-01, E-16) X( 6) = ( E-01, E-15) PATH NUMBER = 16 ARCLEN = E+01 NFE = 131 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E

231 FINITE REAL SOLUTION X( 1) = ( E-01, E-18) X( 2) = ( E+00, E-17) X( 3) = ( E+00, E-17) X( 4) = ( E+00, E-17) X( 5) = ( E+00, E-17) X( 6) = ( E+00, E-16) PATH NUMBER = 17 ARCLEN = E+00 NFE = 95 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-16) X( 2) = ( E+00, E-16) X( 3) = ( E-01, E-16) X( 4) = ( E+00, E-16) X( 5) = ( E-01, E-16) X( 6) = ( E+00, E-15) PATH NUMBER = 18 ARCLEN = E+01 NFE =

232 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-18 FINITE REAL SOLUTION X( 1) = ( E+00, E-15) X( 2) = ( E+02, E-13) X( 3) = ( E+01, E-14) X( 4) = ( E+01, E-14) X( 5) = ( E+01, E-14) X( 6) = ( E-02, E-17) PATH NUMBER = 19 ARCLEN = E+01 NFE = 104 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-15) X( 3) = ( E+00, E-15) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-15) X( 6) = ( E-01, E-16) PATH NUMBER =

233 ARCLEN = E+01 NFE = 102 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-18 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E-01, E-17) X( 3) = ( E-02, E-17) X( 4) = ( E-01, E-17) X( 5) = ( E-01, E-17) X( 6) = ( E-01, E-17) PATH NUMBER = 21 ARCLEN = E+00 NFE = 61 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E+00, E-13) X( 2) = ( E+00, E-13) X( 3) = ( E+00, E-13) X( 4) = ( E+00, E-13) X( 5) = ( E+00, E-14) X( 6) = ( E-01, E-14) 210

234 PATH NUMBER = 22 ARCLEN = E+02 NFE = 197 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E+00, E-17) X( 2) = ( E-01, E-17) X( 3) = ( E-01, E-17) X( 4) = ( E-01, E-17) X( 5) = ( E-01, E-18) X( 6) = ( E+00, E-15) PATH NUMBER = 23 ARCLEN = E+01 NFE = 120 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-17 FINITE REAL SOLUTION X( 1) = ( E-01, E-17) X( 2) = ( E+00, E-16) X( 3) = ( E+01, E-16) X( 4) = ( E+00, E-16) X( 5) = ( E+00, E-16) 211

235 X( 6) = ( E+00, E-16) PATH NUMBER = 24 ARCLEN = E+00 NFE = 67 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-16 FINITE REAL SOLUTION X( 1) = ( E+00, E-15) X( 2) = ( E+00, E-15) X( 3) = ( E+00, E-15) X( 4) = ( E+00, E-15) X( 5) = ( E+00, E-16) X( 6) = ( E-01, E-16) PATH NUMBER = 25 ARCLEN = E+01 NFE = 62 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-15) X( 2) = ( E+00, E-15) X( 3) = ( E+00, E-15) X( 4) = ( E+00, E-14) 212

236 X( 5) = ( E-01, E-14) X( 6) = ( E-01, E-16) PATH NUMBER = 26 ARCLEN = E+01 NFE = 79 IFLAG2 = 11 LAMBDA = E+00, ESTIMATED ERROR = E-15 FINITE REAL SOLUTION X( 1) = ( E-01, E-14) X( 2) = ( E+01, E-13) X( 3) = ( E+01, E-13) X( 4) = ( E+00, E-13) X( 5) = ( E+01, E-13) X( 6) = ( E-02, E-15) =========Number of processors used: 2 ======== Bezout GLP number (BGLP) : 26 Number of finite solutions : 26 Number of finite real solutions : 26 Number of finite complex solutions: 0 Number of solutions at infinity : 0 Number of homotopy path failures : 0 Maximum running time : 7.844E-01 secs ==================================================== 213

237 Appendix B Synthetica User s Guide Synthetica is a computer graphics based interactive program for synthesizing spatial robots. The goal is to provide a platform for researchers to collaborate on the mechanism synthesis and analysis. Synthetica is written in Java therefore is platform independent and runs on multiple operation systems such as Windows and Mac OS X. B.1 System Requirements and Usage Operation Systems: Software Packages: Computer: RAM: Windows 98/2000/XP or Mac OS X Java 2(1.3 or above), GL4Java( ), OpenGL libraries Apple G3 or PC Pentium III (minimum) Apple G4 or PC Pentium IV (recommended) 128MB minimum, 256MB recommended 214

238 Open Save As Rotate Zoom Delete New Save Pan Add On/Off Figure B.1: The toolbar for manipulating files, viewer and objects B.2 Graphical User Interface Components The toolbar consists of three groups of icons, an file I/O group for loading and saving data from and to the local files, a dynamic viewer group for rotating, panning, and zooming the display scene and an object operation group consists of adding, deleting and turning on/off objected displayed in the scene. See Figure B.1. An RR serial chain is off An RRTS parallel chain is on Click to select an object to work on (remove, on/off, display/change joints) Click to select a preserved node turn on/off all objects underneath Figure B.2: The object tree structure The object tree organizes the objects displayed in the graphical scene. Users can select an object using mouse clicking. The data associated with the selected object is displayed in the information panel (the lower left corner). Users can modify and 215

239 operate the object through information panel and tool bar. See Figure B.2 View/Modify drawing options On/Off thefloor On/Off the coordinatesystem Floor properties Click to change background color Click to reset the background properties Click to change floor color Apply the changes immediately Figure B.3: The option dialog The option dialog is for updating various options used by Synthetica at run time. For example, users can change the property of the background such as floor position, color etc. Also a factor for scaling the geometric objects in the viewer panel can specified in the 3D Drawing panel. Copy matrix data from the left text panel noto the local clipboard Copy matrix data from the right text panel onto the system clipboard Paste the matrix data on the local clipboard to the left text panel A text panel with 4 by 4 matrix data Paste the matrix data on the system clipboard to the right text panel Figure B.4: The Matrix4d clipboard 216

240 The matrix clipboard viewer is used for exchanging 4 by 4 homogeneous matrices with external programs. With the matrix clipboard, users can conveniently cut and paste matrices within Synthetica interface as well as the external programs. See Figure B.4. Play Forward Step Forward Faster Forward Pause Drag to any frame Play Backward Step Backward Faster Backward Stop & Reset Figure B.5: The animation toolbar The animation toolbar allows users fully control the animation playback (Figure B.5). Users can play continuously or step, forward or backward and change animation speed. The animation toolbar is enabled when an animation object is selected by the users. The curve of each joint angle is shown in the DataViewer panel (Figure B.6). A frame indicator shows the joint data of the current frame. Frame indicator Click to turn on/off a joint trajectory curve Figure B.6: Data viewer panel for displaying animation frames 217

241 Postion Orientation Figure B.7: The workpiece panel The workpiece panel shows the position and orientation of the unique object workpiece. The workpiece object is the gripper drew in wireframe mode. When user select a mechanism, the workpiece will snap to the end-effector. Therefore users can obtain the end-effector data. When a frame of a trajectory is selected, the workpiece will snap to it and shows the information on the frame. The workpiece orientation is constructed from three angles longitude(θ), latitude(φ), and roll(ψ) (Figure B.8) defined by [R(θ, φ, ψ) = [Y (θ)][x( φ)][z(ψ)] cθcψ sφsθsψ cψsφsθ cθsψ cφsθ = cφsψ cφcψ sφ cψsθ cθsφsψ cθcψsφ + sθsψ cφcθ (B.1) where cθ = cosθ, sθ = sin θ and so on, [X( )], [Y ( )], [Z( )] represent the pure rotation around the axes X,Y,Z respectively, defined by formula (2.2) and (2.3) with zero translations. 218

242 Figure B.8: Longitude(θ), latitude(φ), and roll(ψ) coordinates defining an orientation The mechanism teach panel displays the joint data for a serial or parallel mechanism. For a serial mechanism, driving the joints will cause the forward kinematics executed. The end-effector data is updated dynamically in the workpiece panel (Figure B.7). For a parallel mechanism, driving a joint will execute our general solver. Users can lock a joint and allow other joints free to change. When the Approach button is clicked, the mechanism will modify the joint parameters so that the endeffector can reach as close to the position shown in the workpiece panel as it can. When the Generate button is clicked, the mechanism will approach the goal trajectory using the algorithm presented in Chapter 2. The matrix4d specifier dialog is for modifying 4 by 4 homogeneous matrices. See Figure B.10. This is the most often used GUI component in Synthetica. It can be launched by many panels specifying matrices. For example, users can use it to modify 219

243 Uncheck to disassemble closed chain into multiple serial chains Forc the end-effectors of all sub chains to approach each other Genearte an animation by approaching a spcified goal trajectory Force the end-effector to approcah the position specified by the workpiece data Click to view the chain RR Check to lock the joint All joints in the selected chain Figure B.9: Mechanism teach panel for driving joint parameters. the base frame of a mechanism object. The matrix4d specifier dialog consists of a standard matrix4d panel which is reused in other panels such as trajectory panel. The matrix4d panel consists of two parts, one is for position, the other is for orientation. The orientation part is a 3 by 3 rotation matrix defined by (B.1). Users can convert the orientation matrix from and to the longitude, latitude and roll. The trajectory panel shows the trajectory data which consists of key frames and full list of frames. The full list of frames are obtained through the built-in interpolation code using the key frames. See Figure B

244 Compute long., lat. and Roll from the matrix rotation part Click to load an advanced specifier for the rotation Copy matrix data to the clipboard solution 1 solution 2 Paste matrix data from the clipboard Update matrix data using the workpiece Compute the 3 by 3 rotation matrix from first row of long., lat. and roll data Compute the 3 by 3 rotation matrix from second row of long., lat. and roll data Figure B.10: Matrix4dSpecifier dialog for specifying 4 4 homogeneous matrices Choose a key frame to work on Call interpolation routine to obtain a smooth trajctory Remove the selected a key frame Number of intermediate frame between key frames Click to view all frames of the trajectory Convergence tolerance for interpolation Append a key frame from the Workpiece data Standard 4 by 4 matrix panel Check to draw coordinate frame at the position Click to change the material of the selected frame Shade/wireframe mode Figure B.11: The trajectory panel 221

245 Appendix C Partial Synthetica Source Code C.1 Serial RR 3Pos 0Con.java This file contains sample codes for implementing an inverse kinematics and a three position synthesis routine for RR serial chains. The synthesis formulation is provide by Perez and McCarthy [48]. /* 10/01/ * * Copyright Robotics and Automation Lab, University of California, Irvine. All Rights Reserved. * * This software is the proprietary information of Robotics and Automation Lab, UCI. * Use is subject to license terms. * */ package client; import java.lang.math.*; import javax.vecmath.*; import synthetica.mechanism.*; import synthetica.kinemath.*; /** * Define a Serial RR with a synthesis algorithm which accepts 3 design position and 0 constraints. * A Spatial RR linkage is comprised of a base G, a spatial RR chain and an end-effector H. 222

246 * Souce code can be downloaded here <a HREF="Serial_RR_3Pos_0Con.java">Serial_RR_3Pos_0Con.java</a>. 1.0 */ public class Serial_RR_3Pos_0Con extends SerialMechanism implements InverseKinematics, Synthesizable{ /** A default constrcutor is a must for implementing a new mechanism. * New a spatial RR linkage with unit length and twist angle 0.0; */ public Serial_RR_3Pos_0Con(){ //Default constructor. super("rr"); //RR is the architecture symbol of this synthetica.mechanism. double[][] links = {{0.0, 0.0, {1.0, 0.0; super.setalllinks( links ); /** New a spatial RR linkage with given the G, H, link length, twist angle; G the transform from the base to the first revolute joint. H the transform from the last revolute joint to the end-effector. link_length the link length between the two revolute joints. link_twist the twist angle between the two revolute joints. */ public Serial_RR_3Pos_0Con(Matrix4d G, Matrix4d H, double link_length, double link_twist){ super(g, H, "RR"); double[][] links = {{0.0, 0.0, {link_length, link_twist; super.setalllinks( links ); /** Inverse kinematics of the spatial RR open chain. This interface is not necessary to implement. * <p> [T] = [G] [Z(th1)][X(a, alpha)] [Z(th2)] [H] * <p> [D] = [G^-1][T][H^-1] = [Z(th1)][X(a, alpha)] [Z(th2)]. [D] has the following form. * <p> {{c1*c2 - ca*s1*s2, -ca*c2*s1 - c1*s2, sa*s1, a*c1, * <p> {s1*c2 - ca*c1*s2, ca*c1*c2 - s1*s2, -sa*c1, a*s1, * <p> { sa*s2, sa*c2, ca, 0, * <p> { 0, 0, 0, 1 all inverse solutions. */ public double[][] inversek(matrix4d T){ Matrix4d G = new Matrix4d(); Matrix4d H = new Matrix4d(); getbasegripper( G, H ); Matrix4d invg = new Matrix4d(); invg.invert( G ); //[G]^-1 Matrix4d invh = new Matrix4d(); invh.invert( H ); //[H]^-1 Matrix4d D = new Matrix4d(); //[D] = [G^-1][T][H^-1] = [Z(th1)][X(a, alpha)] [Z(th2)] D.mul( invg, T ); D.mul( invh ); 223

247 //now compute th1, th2 from [D] = [Z(th1)][X(a, alpha)] [Z(th2)] double[][] linkparams = {{0.0, 0.0, {0.0, 0.0; getalllinks( linkparams ); //get the link parameters. double a = linkparams[ 1 ][ 0 ]; double alpha = linkparams[ 1 ][ 1 ]; double ca = Math.cos( alpha ), sa = Math.sin( alpha ); double th1, th2; th1 = Math.atan2( D.m13/a, D.m03/a ); if(math.abs( sa ) > 1e-10 ) th2 = Math.atan2( D.m20/sa, D.m21/sa ); else th2 = Math.atan2( D.m10, D.m11 ) - th1; double[][] th12 = {{th1, th2; return th12; /** *@return 3. This algorithm accepts three finite design positions. */ public int getnumpositions(){ return 3; /** *@return 0. No constraints. */ public int getnumconstraints(){ return 0; /** *@return {"Pos1", "Pos2", "Pos3"; */ public String[] getnamespositions(){ return new String[] {"Pos1", "Pos2", "Pos3"; /** *@return String[0]; No constraints. */ public String[] getnamesconstraints(){ return new String[0]; /** *@return "RR". */ 224

248 public String gettopology(){ return "RR"; /** 2. Two solutions will be otained from this algorithm. */ public int getnumsolutions(){ return 2; /** *the synthesize a spatial RR dyad with three finite positions. */ public Mechanism[] synthesize(designtask task){ if(task.getnumberpositions()>=3) { Serial_RR_3Pos_0Con[] solutions = new Serial_RR_3Pos_0Con[2]; Line4d ginitial = new Line4d(); Line4d winitial = new Line4d(); Line4d hinitial = new Line4d(); Line4d uinitial = new Line4d(); Matrix4d[] poses = task.getallpositionvalues(); designrr3pos( poses, ginitial, winitial, hinitial, uinitial ); solutions[ 0 ] = buildrrdyad( poses, ginitial, winitial ); solutions[ 1 ] = buildrrdyad( poses, hinitial, uinitial ); return solutions; return null; private static void designrr3pos(matrix4d[] pos, Line4d ginitial, Line4d winitial, Line4d hinitial, Line4d uinitial){ int i; Matrix3d[] Rotations = new Matrix3d[3]; Vector3d[] Positions = new Vector3d[3]; for(i=0; i<3; i++){ Rotations[ i ] = new Matrix3d(); Positions[ i ] = new Vector3d(); pos[ i ].get(rotations[ i ], Positions[ i ]); Matrix3d rotmat12 = new Matrix3d(); rotmat12.multransposeright(rotations[1], Rotations[0]); //R12 = R2.R1 ; 225

249 Matrix3d rotmat13 = new Matrix3d(); rotmat13.multransposeright(rotations[2], Rotations[0]); //R13 = R3.R1 ; Vector3d trans1 = new Vector3d(Positions[0]); Vector3d trans2 = new Vector3d(Positions[1]); Vector3d trans3 = new Vector3d(Positions[2]); //trans12 = trans2 - rotmat12*trans1; Vector3d trans12 = new Vector3d(trans1); rotmat12.transform(trans12); trans12.sub(trans2, trans12); //trans13 = trans3 - rotmat13*trans1; Vector3d trans13 = new Vector3d(trans1); rotmat13.transform(trans13); trans13.sub(trans3, trans13); Line4d usc12 = new Line4d(); Line4d usc13 = new Line4d(); //set the screw axis of the displaecment to usc12 and usc13. //And the magnitude of a screw displacement is (rotation angle, translation) DualNumber2d mag12 = usc12.setscrewaxis(rotmat12, trans12); DualNumber2d mag13 = usc13.setscrewaxis(rotmat13, trans13); //Real part is "delta", Image part is "d". d is not forced positive. DualNumber2d delta_d = Line4d.dualAngle(usc12, usc13, false); //calculating z0 and sigma double p12 = mag12.y / (2.0 * Math.tan(mag12.x/2.0) ); double p13 = mag13.y / (2.0 * Math.tan(mag13.x/2.0) ); double sindelta = Math.sin(delta_d.x); double cosdelta = Math.cos(delta_d.x); double z0 = (0.5)*(delta_d.y - (p13 - p12)*cosdelta/sindelta); double sigma = (0.5)*Math.atan2(delta_d.y*sindelta - (p13 - p12)*cosdelta, (p13 - p12)*sindelta + delta_d.y*cosdelta); double delta1 = -sigma, delta2 = delta_d.x - sigma; double Ks, Kd, K12, K13; double t12 = mag12.y, t13 = mag13.y; Ks = (t12*math.cos(delta2) - t13*math.cos(delta1)) / (2.0*Math.sin(delta1-delta2)); 226

250 Kd = (t13*math.sin(delta1) - t12*math.sin(delta2)) / (2.0*Math.sin(delta1-delta2)); double tmp = Math.sin(delta1)*Math.sin(delta1) - Math.sin(delta2)*Math.sin(delta2); double TAN12 = Math.tan(mag12.x/2.0), TAN13 = Math.tan(mag13.x/2.0); K12 = (t12/2.0)/tan12/tmp; K13 = (t13/2.0)/tan13/tmp; //calculate C0, C1, C2, C3 double C0, C1, C2, C3; C0 = Ks*Ks; C1 = 2.0*Ks*Ks - Kd*Kd - 4.0*(K12 - K13)*(K13*Math.cos(delta1)*Math.cos(delta1) - K12*Math.cos(delta2)*Math.cos(delta2)); C2 = Ks*Ks - 2.0*Kd*Kd + 4.0*(K12 - K13)*(K13*Math.sin(delta1)*Math.sin(delta1) - K12*Math.sin(delta2)*Math.sin(delta2)); C3 = -Kd*Kd; double zsol=0.0, kappa=0.0; //Solve the equation: C3*z^3 + C2*z^2 + C1*z + C0 = 0; try { double[] coef = new double[4]; coef[0] = C3; coef[1] = C2; coef[2] = C1; coef[3] = C0; Polynomial poly = new Polynomial(coef); Complex[] zeros = poly.zeros(); for (i=0; i < zeros.length; ++i) { if(math.abs(zeros[i].im()) < && zeros[i].re() > 0.0) //Return the only positive real root. { zsol = zeros[i].re(); break; catch (Exception e) { e.printstacktrace(); kappa = 2.0*Math.atan( Math.sqrt(zsol) ); double sin_kappa_2 = Math.sin(kappa/2.0), cos_kappa_2 = Math.cos(kappa/2.0); //Calculate a, b, c; 227

251 double a, b, c, tmp1, tmp2; tmp1 = Ks/(2.0*sin_kappa_2); tmp2 = Kd/(2.0*cos_kappa_2); a = tmp1 + tmp2; b = tmp1 - tmp2; c = (K13 - K12)*Math.sin(kappa); //G W, written in the Bennett linkage coordinate frame. Vector3d G_Re = new Vector3d(2.0*b*c*sin_kappa_2, 2.0*b*c*cos_kappa_2, 4.0*a*b*cos_kappa_2*sin_kappa_2); Vector3d G_Im = new Vector3d(b*cos_kappa_2*(4.0*a*a*sin_kappa_2*sin_kappa_2 + c*c), -b*sin_kappa_2*(4.0*a*a*cos_kappa_2*cos_kappa_2 + c*c), 2.0*a*b*c*(cos_kappa_2*cos_kappa_2 - sin_kappa_2*sin_kappa_2)); tmp1 = 1.0/G_Re.length(); G_Re.scale(tmp1); G_Im.scale(tmp1); Vector3d W_Re = new Vector3d(-2.0*a*c*sin_kappa_2, 2.0*a*c*cos_kappa_2, 4.0*a*b*cos_kappa_2*sin_kappa_2); Vector3d W_Im = new Vector3d(-a*cos_kappa_2*(4.0*b*b*sin_kappa_2*sin_kappa_2 + c*c), -a*sin_kappa_2*(4.0*b*b*cos_kappa_2*cos_kappa_2 + c*c), 2.0*a*b*c*(cos_kappa_2*cos_kappa_2 - sin_kappa_2*sin_kappa_2)); tmp1 = 1.0/W_Re.length(); W_Re.scale(tmp1); W_Im.scale(tmp1); //H U, written in the Bennett linkage coordinate frame. Vector3d H_Re = new Vector3d( W_Re.x, W_Re.y, -W_Re.z ); Vector3d H_Im = new Vector3d( W_Im.x, W_Im.y, -W_Im.z ); tmp1 = 1.0/H_Re.length(); H_Re.scale(tmp1); H_Im.scale(tmp1); Vector3d U_Re = new Vector3d( G_Re.x, G_Re.y, -G_Re.z ); Vector3d U_Im = new Vector3d( G_Im.x, G_Im.y, -G_Im.z ); tmp1 = 1.0/U_Re.length(); U_Re.scale(tmp1); U_Im.scale(tmp1); // Coordinate Transformation to the Base Frame. And set it dispbp. Matrix4d dispbp = new Matrix4d (); { //Construct the coordinate lines Line4d XAxis = new Line4d(usc12); 228

252 Line4d ZAxis = new Line4d(), YAxis = new Line4d(); //Z axis is along the common normal of usc12 and usc13. ZAxis.dualCross(usc12, usc13); ZAxis.normalize(); //Y axis is the dual cross product of Z, X YAxis.dualCross(ZAxis, XAxis); YAxis.normalize(); //Assemble the rotation matrix Amat and the dual part DAmat Matrix3d Amat = new Matrix3d(); Amat.setRow(0, XAxis.w); Amat.setRow(1, YAxis.w); Amat.setRow(2, ZAxis.w); Matrix3d Dmat = new Matrix3d(); Matrix3d Dmat2 = new Matrix3d(); Dmat.setColumn(0, ZAxis.v); Dmat.setColumn(1, XAxis.v); Vector3d tempvec = new Vector3d(); tempvec.negate(xaxis.v); Dmat.setColumn(2, tempvec); Dmat2.mul(Amat,Dmat); Vector3d transbi= new Vector3d(Dmat2.getElement(1,0),Dmat2.getElement(2,1),Dmat2.getElement(1,2)); Amat.transpose(); //A = A GVector transbi2=new GVector(transBI); GMatrix Abis=new GMatrix(3,3); //Abis.set(-Amat); GMatrix tempmat = new GMatrix(3,3); tempmat.set(amat); tempmat.negate(); Abis.set(tempmat); transbi2.mul(abis,transbi2); //Assemble the 4x4 displacement matrix Matrix4d dispbi = new Matrix4d(); dispbi.setidentity(); dispbi.setrotation(amat); dispbi.setelement(0,3, transbi2.getelement(0)); 229

253 dispbi.setelement(1,3, transbi2.getelement(1)); dispbi.setelement(2,3, transbi2.getelement(2)); Matrix4d dispip = new Matrix4d (Math.cos(sigma), Math.sin(-sigma), 0, 0, Math.sin(sigma), Math.cos(sigma), 0, 0, 0, 0, 1, z0, 0, 0, 0, 1); dispbp.mul(dispbi, dispip); { //Evaluate ginitial, winitial, hinitial, uinitial in the Base Frame. ginitial.set(g_re,g_im); ginitial.transform(dispbp); winitial.set(w_re,w_im); winitial.transform(dispbp); hinitial.set(h_re,h_im); hinitial.transform(dispbp); uinitial.set(u_re,u_im); uinitial.transform(dispbp); private static Serial_RR_3Pos_0Con buildrrdyad(matrix4d[] pos, Line4d G, Line4d W) { Line4d sg = new Line4d(), sw = new Line4d(); sg.normalize(g); sw.normalize(w); //Matrix [G] from the base frame to the fixed axis: the origin of theta is in the common normal line. //Compute common normal to G, W1 and intersection points Line4d norgw = new Line4d(); GScrew6d normalpoints = norgw.commonnormal( sg, sw ); Vector3d yaxis = new Vector3d(); yaxis.cross(sg.w, norgw.w); Matrix3d rotg = new Matrix3d(); rotg.setcolumn(0, norgw.w); //x axis rotg.setcolumn(1, yaxis); //y axis rotg.setcolumn(2, sg.w); //z axis //Assemble the 4x4 displacement matrix 230

254 Matrix4d transg = new Matrix4d(); transg.setidentity(); transg.setrotation(rotg); transg.settranslation( normalpoints.w ); //Create kinematics equations with a, alpha, theta1, theta2. //Find a, alpha. DualNumber2d alphaa = new DualNumber2d(sG.dualAngle(sW)); //construct kinematics homogeneous transforms. rotz is same for both joints, angle zero. Matrix4d KE1 = new Matrix4d(); //KE1= Z[0,0]X[alpha,a][Z[0,0] { Matrix4d m1 = new Matrix4d(); KE1.rotX(alphaa.x); //X[alpha,0] m1.set(1, new Vector3d(alphaa.y, 0, 0)); //X[0,a] KE1.mul(m1); //find [H]=([G][Keqs])^-1.[M1] Matrix4d transh = new Matrix4d(); transh.mul(transg,ke1); transh.invert(); transh.mul(pos[ 0 ]); //check the whole thing: [M1]=[G][Keqs][H] Matrix4d position1 = new Matrix4d(); position1.mul(transg,ke1); position1.mul(transh); Serial_RR_3Pos_0Con solution = new Serial_RR_3Pos_0Con(transG, transh, alphaa.y, alphaa.x); return solution; 231

255 C.2 Joint.java /* 10/01/ * * Copyright Robotics and Automation Lab, University of California, Irvine. All Rights Reserved. * * This software is the proprietary information of Robotics and Automation Lab, UCI. * Use is subject to license terms. * */ package synthetica.mechanism; import java.io.*; import javax.vecmath.*; import gl4java.*; import gl4java.utils.glut.*; import synthetica.kinemath.*; /** * Joint is the super class of all kinds of joints including revolute, prismatic, gimbal, cylinder, * spherical. Users can also define your own joints by extending the class {@link Joint Joint. * 1.0 <a HREF="mailto:Haijun Su <[email protected]>">haijun Su</a> <a HREF="mailto:Curtis Collins <[email protected]>">curtis Collins</a> <a HREF="mailto:J. Michael McCarthy <[email protected]>">j. Michael McCarthy</a> */ public class Joint extends MathFunctions implements Cloneable, ForwardKinematics, InverseKinematics, Drawable, Serializable{ /** revolute joint*/ public static final int JOINT_REVOLUTE = 0; /** prismatic joint*/ public static final int JOINT_PRISMATIC = 1; /** helical joint*/ public static final int JOINT_HELICAL = 2; /** gimbal(or T) joint*/ public static final int JOINT_GIMBAL = 3; /** cylinder joint*/ public static final int JOINT_CYLINDRIC = 4; /** spherical joint*/ public static final int JOINT_SPHERICAL = 5; /** unkown joint*/ 232

256 public static final int JOINT_UNKOWN = 6; /** not a joint joint*/ public static final int JOINT_NOTAJOINT = 0xf; /** {"R", "P", "H", "T", "C", "S", "N", "U" */ public static final String[] JOINT_NAMES = {"R", "P", "H", "T", "C", "S", "N", "U"; public static final String[] JOINT_FULL_NAMES = {"Revolute", "Prismatic", "Helical", "Gimbal", "Cylinder", "Spherical", "Not a joint", "Unkown Joint"; //attributes int m_type = JOINT_REVOLUTE; JointVar[] m_vars; //joint variables. public Joint(){ this( JOINT_REVOLUTE ); public Joint(JointVar[] Variables, int Type){ m_type = Type; m_vars = new JointVar[ Variables.length ]; for( int i = 0; i< m_vars.length; i++){ m_vars [ i ] = new JointVar( Variables [ i ] ); public Joint(JointVar Variable, int Type){ m_type = Type; m_vars = new JointVar[ 1 ]; m_vars [ 0 ] = new JointVar( Variable ); public Joint(int Type){ m_type = Type; switch(m_type){ case JOINT_REVOLUTE: m_vars = new JointVar[ 1 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); break; case JOINT_PRISMATIC: m_vars = new JointVar[ 1 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_LONGULAR ); break; case JOINT_HELICAL: m_vars = new JointVar[ 1 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_ANY ); break; case JOINT_GIMBAL: m_vars = new JointVar[ 2 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); 233

257 m_vars[ 1 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); break; case JOINT_CYLINDRIC: m_vars = new JointVar[ 2 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); m_vars[ 1 ] = new JointVar( JointVar.JOINT_VAR_LONGULAR ); break; case JOINT_SPHERICAL: m_vars = new JointVar[ 3 ]; m_vars[ 0 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); m_vars[ 1 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR, PI/4.0 ); m_vars[ 2 ] = new JointVar( JointVar.JOINT_VAR_ANGULAR ); break; default: break; /** * Set three joint variables to be passive or active. */ public void setpassive(boolean[] Passive){ for(int i = 0; i<min(m_vars.length, Passive.length); i++){ m_vars[ i ].setpassive(passive[ i ]); /** * Set three joint variables to be passive or active. */ public void setpassive(boolean Passive){ boolean[] pass = new boolean[ m_vars.length ]; for(int i = 0; i<m_vars.length; i++){ pass[ i ] = Passive; setpassive( pass ); public void setjointvars(jointvar[] Variables){ int i; if( m_vars.length == Variables.length){ for(i = 0; i<min(m_vars.length, Variables.length); i++){ m_vars[ i ].setall(variables[ i ]); else{ 234

258 m_vars = new JointVar[ Variables.length ]; for(i = 0; i<min(m_vars.length, Variables.length); i++){ m_vars[ i ] = new JointVar( Variables[ i ] ); public void setjointvalues(double[] Values){ for(int i = 0; i<min(m_vars.length, Values.length); i++){ m_vars[ i ].setvalue( Values[ i ] ); public void settype(int Type){ m_type = Type; public void setall( Joint ajoint){ if( ajoint.gettype() == m_type ){ setjointvars( ajoint.getjointvars() ); public void setangle(double aangle) { public double getangle() { return 0.0; public void setoffset(double offset) { public double getoffset() { return 0.0; public double getjointvalue() {return 0.0; ; public int gettype(){ return m_type; public String getname(){ return JOINT_NAMES[ m_type ]; public void getjointvars(jointvar[] Variables){ for(int i = 0; i<min(m_vars.length, Variables.length); i++){ Variables[ i ].setall(m_vars[ i ]); public JointVar[] getcopiedjointvars(){ JointVar[] Variables = new JointVar[ m_vars.length ]; for(int i = 0; i<variables.length; i++){ Variables[ i ] = new JointVar( m_vars[ i ] ); return Variables; /** Be careful to return a package reference. */ 235

259 public JointVar[] getjointvars(){ return m_vars; /** Be careful to return a package reference. */ public JointVar getjointvar( int i){ if( i < m_vars.length ) return m_vars[ i ]; else return null; /** Get the joint values of this joint and set them to the array Values. */ public void getjointvalues(double[] Values){ for(int i = 0; i<min(m_vars.length, Values.length); i++) Values[ i ] = m_vars[ i ].getvalue(); public double[] getjointvalues(){ double[] Values = new double[ m_vars.length ]; getjointvalues( Values ); return Values; public int getnuminternallink(){ return 0; public Link getinternallinkref( int indexlink){ return null; public Object clone(){ try{ Joint cloned = (Joint)super.clone(); cloned.m_vars = new JointVar[ m_vars.length ]; for(int i = 0; i<m_vars.length; i++) cloned.m_vars[ i ] = (JointVar)m_vars[ i ].clone(); return cloned; catch ( CloneNotSupportedException e){ return null; public int getdof(){ int dof = 0; switch(m_type){ case JOINT_REVOLUTE: dof = 1; 236

260 break; case JOINT_PRISMATIC: dof = 1; break; case JOINT_HELICAL: dof = 1; break; case JOINT_GIMBAL: dof = 2; break; case JOINT_CYLINDRIC: dof = 2; break; case JOINT_SPHERICAL: dof = 3; break; default: dof = 0; break; return dof; public Matrix4d gettransform( int i){ Matrix4d m = new Matrix4d(); m.setidentity(); return m; /** save the transformation matrix into mm from the index "start" */ public void getalltransform( Matrix4d[] mm, int start){ /** save the transformation matrix into mm from the index 0 */ public void getalltransform( Matrix4d[] mm){ getalltransform(mm, 0); /** This is only an empty method. The sub classes should override this method. */ public void forwardk(matrix4d T){ /** This is only an empty method. The sub classes should override this method. */ public void forwardk(matrix4d[] T){ /** This is only an empty method. The sub classes should override this method. always true; */ public boolean gotomatrix(matrix4d T){ return true; 237

261 /** This is only an empty method. The sub classes should override this method. always null; */ public double[][] inversek(matrix4d T){ return null; public String tostring(){ String str="joint Type\t= " + JOINT_NAMES[ m_type ] + "\n"; for(int i = 0; i<m_vars.length; i++){ str += "JointVar " + (i+1) + " Information: "+"\n"+ m_vars[ i ].tostring(); return str; /** This is only an empty method. The sub classes should override this method. */ public void draw(glfunc gl, GLContext glj, GLUFunc glu, GLUTFunc glut, int qobj, int flag){ /** *save the DH parameters into the array DHtable (index starts from start index); *DHtable[rowStart+0][colStart] = d; DHtable[rowStart+0][colStart+1] = th; *DHtable[rowStart+1][colStart] = d; DHtable[rowStart+1][colStart+1] = th; * *DHtable[rowStart+2][colStart] = d; DHtable[rowStart+2][colStart+1] = th. *@return 0: th is variable, 1: d is variable, 2: both th and d are variables; -1 error * */ public int getdhparam(double[][] DHtable, int rowstart, int colstart){ return -1; /** This is only an empty method. The sub classes should override this method. */ public void setdhparam(double[][] DHtable, int rowstart, int colstart){ public static Joint newjoint( int Type ){ Joint returnjoint = null; switch(type){ case JOINT_REVOLUTE: returnjoint = new JointR(); break; case JOINT_PRISMATIC: returnjoint = new JointP(); break; case JOINT_HELICAL: returnjoint = new JointH(); break; case JOINT_GIMBAL: returnjoint = new JointT(); 238

262 break; case JOINT_CYLINDRIC: returnjoint = new JointC(); break; case JOINT_SPHERICAL: returnjoint = new JointS(); break; default: break; return returnjoint; 239

263 C.3 Mechanism.java /* 10/01/ * * Copyright Robotics and Automation Lab, University of California, Irvine. All Rights Reserved. * * This software is the proprietary information of Robotics and Automation Lab, UCI. * Use is subject to license terms. * */ package synthetica.mechanism; import java.io.*; import java.util.*; import javax.vecmath.*; import gl4java.*; import gl4java.utils.glut.*; import synthetica.kinemath.*; /** * synthetica.mechanism defines the abstract synthetica.mechanism class. It has a base(g) and a * gripper(h). Users are not supposed to new a synthetica.mechanism(abstract) object. Instead, * extends your synthetica.mechanism class either from SerialMechanism or ParallelMechanism. * 1.0 <a HREF="mailto:Haijun Su <[email protected]>">haijun Su</a> <a HREF="mailto:Curtis Collins <[email protected]>">curtis Collins</a> <a HREF="mailto:J. Michael McCarthy <[email protected]>">j. Michael McCarthy</a> */ public abstract class Mechanism extends MathFunctions implements Drawable, Cloneable, Serializable { /** m_base = G. It s the transformation from the world coordinate system to the first link of the * synthetica.mechanism. */ GeometricObject m_base; /** m_gripper = H. It s the transformation from the last joint of the synthetica.mechanism to the * end-effector. */ Gripper m_gripper; //Constructors public Mechanism(){ m_base = new GeometricObject(); m_gripper = new Gripper(); 240

264 public Mechanism(Mechanism amechanism){ m_base = new GeometricObject( amechanism.m_base ); m_gripper = new Gripper ( amechanism.m_gripper ); public Mechanism(GeometricObject abase, Gripper agripper){ m_base = new GeometricObject( abase ); m_gripper = new Gripper( agripper ); public Mechanism(Matrix4d abase, Matrix4d agripper){ m_base = new GeometricObject( abase ); m_gripper = new Gripper( agripper ); public void setbase(matrix4d abase){ m_base.setpose( abase ); /** transform the base */ public void transformbase(matrix4d m){ (m_base.m_pose).mul( m_base.m_pose, m ); public void setgripper(matrix4d agripper){ m_gripper.setpose( agripper ); /** Set the matrix only, material not changed */ public void setbasegripperposeonly(geometricobject abase, Gripper agripper){ m_base.setpose( abase.m_pose ); m_gripper.setpose( agripper.m_pose ); public void setbasegripper(matrix4d abase, Matrix4d agripper){ m_base.setpose( abase ); m_gripper.setpose( agripper ); public void getbasegripper(matrix4d abase, Matrix4d agripper){ m_base.getpose( abase ); m_gripper.getpose( agripper ); public Gripper getgripperref(){ return m_gripper; public GeometricObject getbaseref(){ return m_base; public void getbase(matrix4d base){ m_base.getpose( base ); 241

265 public void getgripper(matrix4d gripper){ m_gripper.getpose( gripper ); public abstract int getdof(); public abstract int getnumjointvars(); public String tostring(){ String str = m_base.tostring() + m_gripper.tostring(); return str; public String gettopology(){ return "Generic Mechanism"; public Object clone(){ try{ Mechanism cloned = (Mechanism)super.clone(); cloned.m_base = (GeometricObject)this.m_base.clone(); cloned.m_gripper = (Gripper)this.m_gripper.clone(); return cloned; catch ( CloneNotSupportedException e){ return null; /** This is only an empty method. The sub classes should override this method. */ public void draw(glfunc gl, GLContext glj, GLUFunc glu, GLUTFunc glut, int qobj, int flag){ if(!m_base.m_pose.epsilonequals(id4, 1e-8)){//G is transformed, test if G is identity matrix double[] array = SquareMatrix4d.dumpToThisArray( m_base.m_pose ); gl.glmultmatrixd( array ); /** This is only an empty method. The sub classes should override this method. */ public void computeframes(arraylist matrixdata, ArrayList jointvardata){ 242

266 C.4 SerialMechanism.java /* 10/01/ * Copyright Robotics and Automation Lab, University of California, Irvine. All Rights Reserved. * This software is the proprietary information of Robotics and Automation Lab, UCI. * Use is subject to license terms. */ package synthetica.mechanism; import java.io.*; import java.util.*; import javax.vecmath.*; import VisualNumerics.math.*; import gl4java.*; import gl4java.utils.glut.*; import synthetica.glprimitives.*; import synthetica.kinemath.*; /** * SerialMechanism defines the serial mechanisms which has a base(g), * a serial chiain and a gripper(h). If your synthetica.mechanism is a SerialMechanism, * extends your synthetica.mechanism from SerialMechanism. * 1.0 <a HREF="mailto:Haijun Su <[email protected]>">haijun Su</a> <a HREF="mailto:Curtis Collins <[email protected]>">curtis Collins</a> <a HREF="mailto:J. Michael McCarthy <[email protected]>">j. Michael McCarthy</a> */ public class SerialMechanism extends Mechanism implements ForwardKinematics, Drawable, Cloneable, Serializable{ SerialChain m_chain; public SerialMechanism(){ super(); public SerialMechanism(GeometricObject Base, Gripper agripper, SerialChain achain){ super( Base, agripper ); m_chain = new SerialChain( achain ); public SerialMechanism(Matrix4d Base, Matrix4d agripper, SerialChain achain){ super( Base, agripper ); m_chain = new SerialChain( achain ); public SerialMechanism(Matrix4d Base, Matrix4d agripper, String Name){ super( Base, agripper ); 243

267 m_chain = new SerialChain( Name ); public SerialMechanism(String Name){ super(new Matrix4d(1, 0, 0, -0.2, 0, 1, 0, -0.2, 0, 0, 1, 0.2, 0, 0, 0, 1), new Matrix4d(1, 0, 0, 0.2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)); m_chain = new SerialChain( Name ); public SerialMechanism(SerialChain achain){ super(new Matrix4d(1, 0, 0, -0.2, 0, 1, 0, -0.2, 0, 0, 1, 0.2, 0, 0, 0, 1), new Matrix4d(1, 0, 0, 0.2, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)); m_chain = new SerialChain( achain ); public SerialMechanism(SerialMechanism aserialmechanism){ super(aserialmechanism.m_base, aserialmechanism.m_gripper); m_chain = new SerialChain( aserialmechanism.m_chain ); public static SerialMechanism getdefaultserialmechrr(){ Matrix4d matrixg = new Matrix4d( , , , , , , , , , , , , 0,0,0,1); Matrix4d matrixh = new Matrix4d( , , , , , , , , , , , , 0,0,0,1); return new SerialMechanism(matrixG, matrixh, SerialChain.getDefaultSerialChainRR()); public static SerialMechanism getdefaultserialmechts(){ Matrix4d matrixg = new Matrix4d( , , , 0.5, , , 0.0, 1.0, , , , 0.5, 0,0,0,1); Matrix4d matrixh = new Matrix4d( 1.0, 0.0, 0.0, , 0.0, 1.0, 0.0, , 0.0, 0.0, 1.0, , 0,0,0,1); return new SerialMechanism(matrixG, matrixh, SerialChain.getDefaultSerialChainTS()); ////////////////////////////////////////////////////////////////////////////////// 244

268 public void setchain(serialchain achain){ m_chain.setall( achain ); public void setalljointvalues(double[] Values){ setalljointvalues(values, 0); public void setalljointvalues(double[] Values, int startindex){ m_chain.setalljointvalues( Values, startindex ); public void setalljointvalues(double[][] Values){ m_chain.setalljointvalues( Values[0] ); /** Set the value of a joint variable */ public void setajointvalue(int indexjointvar, double Value){ m_chain.setajointvalue(indexjointvar, Value ); /** Get the value of a joint variable */ public double getajointvalue(int indexjointvar){ return m_chain.getajointvalue(indexjointvar); /** Set the all link with an array of Links. Links is an array. Each row of Links is used to set a link. {length, twist angle */ public void setalllinks(double[][] Links){ m_chain.setalllinks( Links ); public void setall(serialmechanism aserialmechanism){ m_chain.setall( aserialmechanism.m_chain ); m_base.setall( aserialmechanism.m_base ); m_gripper.setall( aserialmechanism.m_gripper ); public void applyminmaxajointvar(int indexjointvar){ m_chain.applyminmaxajointvar( indexjointvar ); public void applyminmaxalljointvar(){ m_chain.applyminmaxalljointvar(); public int getdof(){ return m_chain.getdof(); public int getnumjointvars(){ return getdof(); public void getalllinks(double[][] Links){ 245

269 m_chain.getalllinks( Links ); public void getalllinks(link[] Links){ m_chain.getalllinks( Links ); public double[] getalljointvalues(){ return m_chain.getalljointvalues(); public void getalljointvalues(double[] values){ getalljointvalues(values, 0); public void getalljointvalues(double[] values, int startindex){ m_chain.getalljointvalues(values, startindex); public SerialChain getchainref(){ return m_chain; /** *set type[i] to be true if the ith joint var is a angular variable *false otherwise */ public void getalljointvartypes(boolean[] type){ m_chain.getalljointvartypes( type ); public boolean[] getalljointvartypes(){ return m_chain.getalljointvartypes(); /** DHtable is a n by 4 array. Each row has the form [alpha, a, d, th] * return [0]: is the link internal or external * return [1]: is revolute or prismatic joint var */ public int[][] getdhtable(double[][] DHtable){ return m_chain.getdhtable( DHtable ); /** DHtable is a n by 4 array. Each row has the form [alpha, a, d, th] * assume DHtable has valid data */ public void setdhtable(double[][] DHtable){ m_chain.setdhtable( DHtable ); /** 246

270 DHtable is a n by 4 array. Each row has the form [alpha, a, d, th] * assume DHtable has valid data * upate a row only */ public void setdhtable(double[][] DHtable, int row){ m_chain.setdhtable( DHtable, row ); the number of links. This method differs getnumoflinks in that this method counts the * internal link of the S and T joints */ public int getnumoflinkswithinternal(){ return m_chain.getnumoflinkswithinternal(); /** *@return the transform matrix from the first joint to the joint with index = indexofjointvar */ public Matrix4d gettransform( int indexofjointvar){ Matrix4d transformchain = m_chain.gettransform( indexofjointvar); Matrix4d m = new Matrix4d(); getbase( m ); //m = G if(transformchain!=null){ m.mul( transformchain ); //G.[T] return m; else return null; the transform matrices for all joint variables */ public void getalltransform(matrix4d[] mm){ if( mm.length >= getdof() ){ Matrix4d matrixg = new Matrix4d(); getbase( matrixg ); Matrix4d tmp = new Matrix4d(); m_chain.getalltransform( mm ); for(int i=0; i<mm.length; i++){ tmp.mul(matrixg, mm[i]); mm[i].set( tmp ); /** Compute the pluckler coordinate of any joint axis */ public Line4d getjointaxis( int indexofjointvar){ Line4d screwaxis = null; if( indexofjointvar < getdof() ){ 247

271 Matrix4d m = gettransform( indexofjointvar ); Vector3d s = new Vector3d(m.m02, m.m12, m.m22); //z axis of the frame if( m_chain.getjointvarrefwithinternal( indexofjointvar ).gettype() == JointVar.JOINT_VAR_LONGULAR ){ screwaxis = new Line4d(new Vector3d(), s); // [0 s] return screwaxis; Vector3d c = new Vector3d(m.m03, m.m13, m.m23); //origin of the frame Vector3d cxs = new Vector3d(); cxs.cross(c, s); screwaxis = new Line4d(s, cxs); //[s c x s] return screwaxis; /** * Compute the screw Jacobian matrix [J] of the serial mechanism. [J] is 6 by n matrix, * where n is the DOF of the serial mechanism. Each column of the screw Jacobian is the pluckler * coordinate of the each joint axis and is one of the following two cases: * [s cxs] if it is a revolute joint or * [0 s] if it is a prismatic joint */ public Line4d[] getscrewjacobian(){ Line4d[] screwaxes = new Line4d[ getdof() ]; for(int i=0; i<screwaxes.length; i++){ screwaxes[ i ] = getjointaxis( i ); return screwaxes; /** * Compute the conventional Jacobian matrix [J] of the serial mechanism. [J] is 6 by n matrix, * where n is the DOF of the serial mechanism. Each column of the screw Jacobian is one of the * following two cases: * [sx(pi) s] if it is a revolute joint or * [s 0] if it is a prismatic joint * where, s is the z axis (or the joint axis ). pi is the vector from the a point on the ith * joint axis to the end-effector. */ public void getregularjacobian(gscrew6d[] Jacobian){ int i,dof = getdof(); Matrix4d[] transforms = new Matrix4d[dof]; for(i=0; i<dof; i++){ transforms[i] = new Matrix4d(); 248

272 getalltransform( transforms ); convertmatrixtojacobian( transforms, Jacobian ); public void getregularjacobian(double[][] Jacobian){ int i,dof = getdof(); GScrew6d[] JacobianLines = new GScrew6d[dof]; for(i=0; i<dof; i++){ JacobianLines[i] = new GScrew6d(); double[] col = new double[6]; getregularjacobian( JacobianLines ); for(i=0; i<dof; i++){ JacobianLines[i].portToArray( col ); for(int j=0; j<col.length; j++){ Jacobian[j][i] = col[j]; //save to Jacobian by columns /** *Given the transformation matrices of each joint axis, compute the conventional Jacobian matrix */ public void convertmatrixtojacobian(matrix4d[] transforms, GScrew6d[] Jacobian){ int i,dof = getdof(); Vector3d v1 = new Vector3d(); Vector3d v2 = new Vector3d(); Matrix4d matrixh = new Matrix4d(); getgripper( matrixh ); Matrix4d matrixgripper = new Matrix4d(transforms[dof-1]); matrixgripper.mul( matrixh ); //the matrix of the end-effector //origin of the last transformation matrix Vector3d vgripper = new Vector3d(matrixGripper.m03, matrixgripper.m13, matrixgripper.m23); for(i=0; i<dof; i++){ if( m_chain.getjointvarrefwithinternal( i ).gettype() == JointVar.JOINT_VAR_LONGULAR ){ //translational joint variable //z axis of the ith transformation matrix v1.set(transforms[i].m02, transforms[i].m12, transforms[i].m22); v2.set(0.0, 0.0, 0.0); //(0,0,0) else{ //roational joint variable //z axis of the ith transformation matrix v2.set(transforms[i].m02, transforms[i].m12, transforms[i].m22); //origin of the ith transformation matrix v1.set(transforms[i].m03, transforms[i].m13, transforms[i].m23); 249

273 v1.sub(vgripper, v1); v1.cross(v2, v1); //zi x (pn - oi) Jacobian[i].set(v1, v2); public String gettopology(){ return m_chain.gettopology(); public void forceeofadjustgripper(matrix4d goaleof){ Matrix4d m = new Matrix4d(); forwardk( m ); m.invert(); m.mul(goaleof); Matrix4d gripper = new Matrix4d(); getgripper( gripper ); gripper.mul( m ); setgripper( gripper ); /** Inverse kinematics of this serial synthetica.mechanism. Set one of two solutions to this joint. * The second joint variable is always positive. To get both solutions, use the * {@link inversek(matrix4d, JointS[]) inversek(matrix4d T, JointS[] solutions) method. T [G].[D].[H] where G is the transform from the base to the first joint of the serial * chain. H is the transform from the last joint of the chain to the end-effector. D is the * transform of the kinematic chain. */ public void forwardk(matrix4d T){ Matrix4d m = new Matrix4d(); Matrix4d G = new Matrix4d(); Matrix4d H = new Matrix4d(); getbasegripper( G, H ); m_chain.forwardk( m ); T.set( G ); T.mul( m ); T.mul( H ); public Matrix4d getendofeffector(){ Matrix4d T = new Matrix4d(); forwardk( T ); return T; public void forwardk(double[] jointvars, Matrix4d T){ double[] oldjointvars = getalljointvalues(); setalljointvalues( jointvars ); forwardk( T ); 250

274 setalljointvalues( oldjointvars ); public Matrix4d forwardk(double[] jointvars){ Matrix4d T = new Matrix4d(); forwardk( jointvars, T); return T; public void forwardk(matrix4d[] T){ forwardk( T[ 0 ] ); public String tostring(){ String str = "G = \n" + m_base.tostring() + m_chain.tostring() + "H = \n" + m_gripper.tostring(); return str; public Object clone(){ SerialMechanism cloned = (SerialMechanism)super.clone(); cloned.m_chain = (SerialChain)this.m_chain.clone(); return cloned; public String tostringjointvalues(){ String str=""; double[] jointvalues = getalljointvalues(); for(int i=0; i<jointvalues.length; i++){ str+=" " + jointvalues[i]; str+="\n"; return str; public void setalllinkmaterialproperty(materialproperty[] mats){ m_chain.setalllinkmaterialproperty( mats ); /** * The method calls the draw() method of m_base, m_chain and then m_gripper. flag 0: draw the gripper others: draw the gripper. */ public void draw(glfunc gl, GLContext glj, GLUFunc glu, GLUTFunc glut, int qobj, int flag){ super.draw(gl, glj, glu, glut, qobj, 0); //draw the base m_chain.draw(gl, glj, glu, glut, qobj, 1); //draw the chain Vector3d posh = new Vector3d(); m_gripper.m_pose.get( posh ); if( flag==0){ gl.glpushmatrix(); m_gripper.draw(gl,glj,glu,glut,qobj,0x7);//draw the gripper + frame system + shaded mode 251

275 gl.glpopmatrix(); //draw the last link m_gripper.matproperty.setproperty( GLEnum.GL_REPLACE ); GeometricPrimitives.drawLastLink((m_chain.m_joints[m_chain.m_joints.length-1]).getType(),posH); /** jointvardata input the joint variables matrixdata output the matrix using forward kinematics */ public void computeframes(arraylist matrixdata, ArrayList jointvardata){ double[] oldjointvalues = getalljointvalues(); try{ matrixdata.clear(); for(int i=0; i<jointvardata.size(); i++){ Object adata = jointvardata.get(i); if(adata instanceof double[] ){ Matrix4d m = new Matrix4d(); setalljointvalues((double[])adata); forwardk( m ); matrixdata.add( m ); else if(adata instanceof double[][] ){ Matrix4d m = new Matrix4d(); setalljointvalues((double[][])adata); forwardk( m ); matrixdata.add( m ); setalljointvalues(oldjointvalues ); catch(exception e){ setalljointvalues(oldjointvalues ); public void pathapproximation(matrix4d[] goalmatrices, ArrayList jointvardata){ double[] oldjointvalues = getalljointvalues(); jointvardata.clear(); for(int i=0; i<goalmatrices.length; i++){ this.approach( goalmatrices[ i ] ); jointvardata.add(this.getalljointvalues()); setalljointvalues(oldjointvalues ); 252

276 public void approachtrjectory(matrix4d[] goalmatrices, ArrayList jointvardata, Matrix4d[] realmatrices){ double[] oldjointvalues = getalljointvalues(); jointvardata.clear(); for(int i=0; i<goalmatrices.length; i++) { jointvardata.add(null); Matrix4d m = new Matrix4d(); forwardk( m ); //current position of end-effector int startindex = MathFunctions.closestFrameIndex(m, goalmatrices); double[] startjointvalues = null; //first half, from startindex back to 0 for(int i=startindex; i>=0; i--){ if(i==startindex) startjointvalues = getalljointvalues(); this.approach( goalmatrices[ i ] ); jointvardata.set(i, this.getalljointvalues()); forwardk( realmatrices[ i ] ); if(i==0){ oldjointvalues = getalljointvalues(); //go back to the start index if(startjointvalues!=null) setalljointvalues( startjointvalues ); for(int i=startindex+1; i<goalmatrices.length; i++){ this.approach( goalmatrices[ i ] ); jointvardata.set(i, this.getalljointvalues()); forwardk( realmatrices[ i ] ); //go back to the start index again setalljointvalues(oldjointvalues ); public void approachtrjectoryusingparallel(matrix4d[] goalmatrices, ArrayList jointvardata, Matrix4d[] realmatrices){ SerialMechanism[] serialmechanisms = {this; ParallelMechanism tmpparamech = new ParallelMechanism(serialMechanisms); tmpparamech.approachtrjectory(goalmatrices, jointvardata, realmatrices); public double approachquaternion(matrix4d goalmtx){ SerialMechanism[] serialmechanisms = {this; ParallelMechanism tmpparamech = new ParallelMechanism(serialMechanisms); 253

277 return tmpparamech.approachquaternion(goalmtx); public double approach(matrix4d goalmtx){ try{ int jj, i, dof = getdof(); double[][] JJ = new double[6][dof]; Matrix4d m = new Matrix4d(); double[] errorcolumn = new double[6]; double epsilon = 1e-8, errorall=0.0, errorallprev = 1.0; DoubleSVD doublesvd = null; //used to solve the linear equation double[] deltavar = null; for(jj=0; jj<200; jj++){ forwardk( m ); SquareMatrix4d.computeErrorColumn(goalMtx, m, errorcolumn, 0); errorall = squarearray(errorcolumn); if(errorall<1e-8 (jj>0 & errorallprev < errorall) ) break; else{ getregularjacobian( JJ ); doublesvd = new DoubleSVD(JJ, epsilon); double[] S = doublesvd.s(); double[][] invdoublesvd = doublesvd.inverse(); deltavar = DoubleMatrix.multiply(invDoubleSVD, errorcolumn); for(i=0; i<dof; i++) setajointvalue( i, getajointvalue(i) + deltavar[i] ); errorallprev = errorall; applyminmaxalljointvar(); return errorall; catch(exception e){ return -1.0; 254