Artifact d99036836423cb89c9590742e44fab815d33678daa3ffabe4402fbb7cde9f829:
- File
r34/doc/gentran.tex
— part of check-in
[f2fda60abd]
at
2011-09-02 18:13:33
on branch master
— Some historical releases purely for archival purposes
git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/trunk/historical@1375 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 197812) [annotate] [blame] [check-ins using] [more...]
\documentstyle[fullpage,gentran]{report} % Suppress hyphenation: \hyphenpenalty 10000 \sloppy % Will print out a heading in bold, and then indent the following text. \def\indented{\list{}{ \itemindent\listparindent \rightmargin\leftmargin}\item[]} \let\endindented=\endlist \newenvironment{describe}[1]{\par{\bf #1}\begin{indented}}{\end{indented}} \setlength{\parskip}{\medskipamount} \setlength{\parindent}{0pt} \begin{document} \pagenumbering{roman} \title{\bf GENTRAN USER'S MANUAL \\ REDUCE VERSION} \author{Barbara L. Gates \\ The RAND Corporation \\ \\ {\em Updated for Reduce 3.4 by} \\ Michael C. Dewar \\ The University of Bath \\ JANET: mcd@uk.ac.bath.maths\\ } \date{February 1991} \maketitle \begin{abstract} GENTRAN is an automatic code GENerator and TRANslator which runs under REDUCE and VAXIMA. It constructs complete numerical programs based on sets of algorithmic specifications and symbolic expressions. Formatted FORTRAN, RATFOR or C code can be generated through a series of interactive commands or under the control of a template processing routine. Large expressions can be automatically segmented into subexpressions of manageable size, and a special file-handling mechanism maintains stacks of open I/O channels to allow output to be sent to any number of files simultaneously and to facilitate recursive invocation of the whole code generation process. GENTRAN provides the flexibility necessary to handle most code generation applications. This manual describes usage of the GENTRAN package for REDUCE. \end{abstract} \chapter*{Acknowledgements} The GENTRAN package was created at Kent State University to generate numerical code for computations in finite element analysis. I would like to thank Prof. Paul Wang for his guidance and many suggestions used in designing the original package for VAXIMA. The second version of GENTRAN was implemented at Twente University of Technology to run under REDUCE. It was designed to be interfaced with a code optimization facility created by Dr. J. A. van Hulzen. I would like to thank Dr. van Hulzen for all of his help in the implementation of GENTRAN in RLISP during a stay at his university in The Netherlands. Finally, I would like to thank Dr. Anthony Hearn of the RAND Corporation for his help in better integrating GENTRAN into the REDUCE environment. Barbara L. Gates. \tableofcontents \chapter{INTRODUCTION} \pagenumbering{arabic} Solving a problem in science or engineering is often a two-step process. First the problem is modeled mathematically and derived symbolically to provide a set of formulas which describe how to solve the problem numerically. Next numerical programs are written based on this set of formulas to efficiently compute specific values for given sets of input. Computer algebra systems such as REDUCE (Hearn, 1985) provide powerful tools for use in the formula-derivation phase but only provide primitive program-coding tools. The GENTRAN package (Gates, 85a, 85b, 86) has been constructed to automate the tedious, time consuming and error-prone task of writing numerical programs based on a set of symbolic expressions. \section{The GENTRAN Code Generator and Translator} The GENTRAN code GENeration and TRANslation package, originally implemented in Franz LISP to run under VAXIMA (Gates \& Wang, 1984), is now also implemented in RLISP (Utah Symbolic Computation Group, 1984) to run under REDUCE. Although GENTRAN was originally created specifically to generate numerical code for use with an existing FORTRAN-based finite element analysis package (Wang, 1986), (Wang {\it et al.}, 1984), it was designed to provide the flexibility required to handle most code generation applications. GENTRAN contains code generation commands, file-handling commands, mode switches, and global variables, all of which are accessible from both the algebraic and symbolic modes of REDUCE to give the user maximal control over the code generation process. Formatted FORTRAN (ANSI, 1978), RATFOR (Kernighan, 1979), C (Kernighan \& Ritchie, 1978) or PASCAL code can be generated from algorithmic specifications, i.e., descriptions of the behaviour of the target numerical program expressed in the REDUCE programming language, and from symbolically derived expressions and formulas. In addition to arithmetic expressions and assignment statements, GENTRAN can also generate type declarations and control-flow structures. Code generation can be guided by user-supplied template file(s) to insert generated code into pre-existing program skeletons, or it can be accomplished interactively through a series of translation commands without the use of template files. Special mode switches enable the user to turn on or off specific features such as automatic segmentation of large expressions, and global variables allow the user to modify the code formatting process. Generated code can be sent to one or more files and, optionally, to the user's terminal. Stacks of open I/O channels facilitate temporary output redirection and recursive invocation of the code generation process. \section{Code Optimisation} A code optimiser (van Hulzen, 1989), which runs under REDUCE, has been constructed to reduce the arithmetic complexity of a set of symbolic expressions. It optimises them by extracting common subexpressions and assigning them to temporary variables which are inserted in their places. The optimisation technique is based on mapping the expressions onto a matrix of coefficients and exponents which are searched for patterns corresponding to the common subexpressions. Due to this process the size of the expressions is often considerably reduced. GENTRAN and the Code Optimiser have been interfaced to make it possible to generate optimised numerical programs directly from REDUCE. Setting the switch {\bf GENTRANOPT} {\bf ON} specifies that all sequences of assignment statements are to be optimised before being converted to numerical code. \section{Organisation of the Manual} The remainder of this manual is divided into five sections. Sections 2 and 3 describe code generation. Section 2 explains interactive code generation, the expression segmentation facility, and how temporary variables can be generated; then section 3 explains how code generation can be guided by a user-supplied template file. Section 4 describes methods of output redirection, and section 5 describes user-accessible global variables and mode switches which alter the code generation process. Finally section 6 presents three complete examples. \subsection{Typographic Conventions} The following conventions are used in the syntactic definitions of commands in this manual: \begin{itemize} \item[{-}] Command parts which must be typed exactly as shown are given in {\bf BOLD PRINT}. \item[{-}] User-supplied arguments are {\it emphasised}. \item[{-}] [ ... ] indicate optional command parts. \end{itemize} The syntax of each GENTRAN command is shown terminated with a {\bf ;}. However, either {\bf ;} or {\bf \$} can be used to terminate any command with the usual REDUCE meaning: {\bf ;} indicates that the returned value is to be printed, while {\bf \$} indicates that printing of the returned value is to be suppressed. Throughout this manual it is stated that file name arguments must be atoms. The exact type of atom (e.g., identifier or string) is system and/or site dependent. The instructions for the implementation being used should therefore be consulted. \chapter{INTERACTIVE CODE GENERATION} GENTRAN generates numerical programs based on algorithmic specifications in the REDUCE programming language and derived symbolic expressions produced by REDUCE evaluations. FORTRAN, RATFOR, PASCAL or C code can be produced. Type declarations can be generated, and comments and other literal strings can be inserted into the generated code. In addition, large arithmetic expressions can be automatically segmented into a sequence of subexpressions of manageable size. This section explains how to select the target language, generate code, control expression segmentation, and how to generate temporary variable names. \section{Target Language Selection} \label{gentranlang} Before generating code, the target numerical language must be selected. GENTRAN is currently able to generate FORTRAN, RATFOR, PASCAL and C code. The global variable {\bf GENTRANLANG!*} determines which type of code is produced. {\bf GENTRANLANG!*} can be set in algebraic or symbolic mode. It can be set to any value, but only four atoms have special meaning: {\bf FORTRAN}, {\bf RATFOR}, {\bf PASCAL} and {\bf C}. Any other value is assumed to mean {\bf FORTRAN}. {\bf GENTRANLANG!*} is always initialised to {\bf FORTRAN}. \section{Translation} \label{translation} The {\bf GENTRAN} (GENerate/TRANslate) command is used to generate numerical code and also to translate code from algorithmic specifications in the REDUCE programming language to code in the target numerical language. Section~\ref{generation} explains code {\it generation}. This section explains code {\it translation}. A substantial subset of all expressions and statements in the REDUCE programming language can be translated directly into numerical code. The {\bf GENTRAN} command takes a REDUCE expression, statement, or procedure definition, and translates it into code in the target language. \begin{describe}{Syntax:} {\bf GENTRAN} {\it stmt} [ {\bf OUT} {\it f1,f2,\dots\ ,fn} ]{\it ;} \end{describe} \begin{describe}{Arguments:} {\it stmt} is any REDUCE expression, statement (simple, compound, or group), or procedure definition that can be translated by GENTRAN into the target language\footnote{See Appendix A for a complete listing of REDUCE expressions and statements that can be translated.} {\it stmt} may contain any number of calls to the special functions {\bf EVAL}, {\bf DECLARE}, and {\bf LITERAL} (see sections~\ref{translation}~--~\ref{comments}). {\it f1,f2,\dots\ ,fn } is an optional argument list containing one or more {\it f}'s, where each {\it f} is one of: \par \begin{tabular}{lll} {\it an atom} &= &an output file\\ {\bf T} &= &the terminal\\ {\bf NIL} &= &the current output file(s)\\ {\bf ALL!*} &= &all files currently open for output by GENTRAN (see section 4)\\ \end{tabular} \end{describe} \begin{describe}{Side Effects:} {\bf GENTRAN} translates {\it stmt} into formatted code in the target language. If the optional part of the command is not given, generated code is simply written to the current output file. However, if it is given, then the current output file is temporarily overridden. Generated code is written to each file represented by {\it f1,f2,\dots\ ,fn} for this command only. Files which were open prior to the call to {\bf GENTRAN} will remain open after the call, and files which did not exist prior to the call will be created, opened, written to, and closed. The output stack will be exactly the same both before and after the call. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRAN} returns the name(s) of the file(s) to which code was written. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) \end{verbatim} \begin{verbatim} ***** WRONG TYPE OF ARG \end{verbatim} exp \begin{verbatim} ***** CANNOT BE TRANSLATED \end{verbatim} \end{describe} \begin{describe}{Examples:\footnote{When the {\bf PERIOD} flag (default setting: ON) is turned on, all integers are automatically printed as real numbers except exponents, subscripts in subscripted variables, and index values in DO-type loops.}} \begin{verbatim} 1: GENTRANLANG!* := 'FORTRAN$ 2: GENTRAN 2: FOR I:=1:N DO 2: V(I) := 0$ DO 25001 I=1,N V(I)=0.0 25001 CONTINUE 3: GENTRANLANG!* := 'RATFOR$ 4: GENTRAN 4: FOR I:=1:N DO 4: FOR J:=I+1:N DO 4: << 4: X(J,I) := X(I,J); 4: Y(J,I) := Y(I,J) 4: >>$ DO I=1,N DO J=I+1,N { X(J,I)=X(I,J) Y(J,I)=Y(I,J) } 5: GENTRANLANG!* := 'C$ 6: GENTRAN 6: P := FOR I:=1:N PRODUCT I$ { P=1; for (I=1;I<=N;++I) P*=I; } 7: GENTRANLANG!* := 'PASCAL$ 8: GENTRAN 8: S := FOR I := 1:10 SUM V(I)$ BEGIN S:=0; FOR I:=1 TO 10 DO S:=S+V(I) END; \end{verbatim} \end{describe} Translation is a convenient method of producing numerical code when the exact behaviour of the resultant code is known. It gives the REDUCE user who is familiar with the syntax of statements in the REDUCE programming language the ability to write code in a numerical programming language without knowing the exact syntactical requirements of the language. However the {\em real} power of the {\bf GENTRAN} command lies in its ability to generate code: it can produce numerical code from symbolic expressions derived in REDUCE in addition to translating statements directly. This aspect is described in section~\ref{generation}. \section{Precision} \label{precision} By default {\bf GENTRAN} generates constants and type declarations in single precision form. If the user requires double precision output then the switch {\bf DOUBLE} must be set {\bf ON}. This does the following: \begin{itemize} \item Declarations of appropriate type are converted to their double precision counterparts. In FORTRAN and RATFOR this means that objects of type {\it REAL\/} are converted to objects of type {\it DOUBLE PRECISION\/} and objects of type {\it COMPLEX\/} are converted to {\it COMPLEX*16\/} \footnote{This is not part of the ANSI FORTRAN standard. Some compilers accept {\it DOUBLE COMPLEX\/} as well as, or instead of, {\it COMPLEX*16\/}, and some accept neither.}. In C the counterpart of {\it float\/} is {\it double\/}, and of {\it int\/} is {\it long\/}. There is no complex data type and trying to translate complex objects causes an error. \item Similarly subprograms are given their correct type where appropriate. \item In FORTRAN and RATFOR {\it REAL\/} and {\it COMPLEX\/} numbers are printed with the correct double precision format. \item Intrinsic functions are converted to their double precision counterparts (e.g. in FORTRAN $SIN \rightarrow DSIN$ etc.). \end{itemize} \subsection{Intrinsic FORTRAN and RATFOR functions.} An attempt is made to convert the arguments of intrinsic functions to the correct type. For example: \begin{verbatim} 5: GENTRAN f:=sin(1)$ F=SIN(1.0) 6: GENTRAN f:=sin(x)$ F=SIN(REAL(X)) 7: GENTRAN DECLARE <<x:real>>$ 8: GENTRAN f:=sin(x)$ F=SIN(X) \end{verbatim} Which function is used to coerce the argument may, of course, depend on the setting of the switch {\bf DOUBLE}. \subsection{Number of printed floating point digits.} To ensure that the correct number of floating point digits are generated it may be necessary to use either the {\bf PRECISION} or {\bf PRINT!-PRECISION} commands. The former alters the number of digits REDUCE calculates, the latter only the number of digits REDUCE prints. Each takes an integer argument. It is not possible to set the printed precision higher than the actual precision. Calling {\bf PRINT!-PRECISION} with a negative argument causes the printed precision to revert to the actual precision. \begin{verbatim} 1: on rounded$ 2: precision 16$ 3: 1/3; 0.333 33333 33333 333 4: print!-precision 6$ 5: 1/3; 0.333333 6: print!-precision(-1)$ 7: 1/3; 0.333 33333 33333 333 \end{verbatim} \section{Code Generation: Evaluation Prior to Translation} \label{generation} Section~\ref{translation} showed how REDUCE statements and expressions can be translated directly into the target language. This section shows how to indicate that parts of those statements and expressions are to be handed to REDUCE to be evaluated before being translated. In other words, this section explains how to generate numerical code from algorithmic specifications (in the REDUCE programming language) and symbolic expressions. Each of the following four subsections describes a special function or operator that can be used to request partial or full evaluation of expressions prior to translation. Note that these functions and operators have the described effects {\it only} when applied to arguments to the {\bf GENTRAN} function and that evaluation is done in algebraic or symbolic mode, depending on the value of the REDUCE variable {\bf !*MODE}. \subsection{The EVAL Function} \label{eval} \begin{describe}{Syntax:} {\bf EVAL} {\it exp} \end{describe} \begin{describe}{Argument:} {\it exp} is any REDUCE expression or statement which, after evaluation by REDUCE, results in an expression that can be translated by GENTRAN into the target language. \end{describe} \begin{describe}{Side Effect:} When {\bf EVAL} is called on an expression which is to be translated, it tells {\bf GENTRAN} to give the expression to REDUCE for evaluation first, and then to translate the result of that evaluation. \end{describe} \begin{describe}{Example:} The following formula, F, has been derived symbolically: \begin{verbatim} 2 2*X - 5*X + 6 \end{verbatim} We wish to generate an assignment statement for the quotient of F and its derivative. \begin{verbatim} 1: GENTRAN 1: Q := EVAL(F)/EVAL(DF(F,X))$ Q=(2.0*X**2-(5.0*X)+6.0)/(4.0*X-5.0) \end{verbatim} \end{describe} \subsection{The :=: Operator} \label{rsetq} In many applications, assignments must be generated in which the left-hand side is some known variable name, but the right-hand side is an expression that must be evaluated. For this reason, a special operator is provided to indicate that the expression on the right-hand side is to be evaluated prior to translation. This special operator is {\bf :=:} (i.e., the usual REDUCE assignment operator with an extra ``:'' on the right). \begin{describe}{Example:} \begin{verbatim} 1: GENTRAN 1: DERIV :=: DF(X^4-X^3+2*x^2+1,X)$ DERIV=4.0*X**3-(3.0*X**2)+4.0*X \end{verbatim} \end{describe} Each built-in operator in REDUCE has an alternative alphanumeric identifier associated with it. Similarly, the GENTRAN {\bf :=:} operator has a special identifier associated with it: {\bf RSETQ} may be used interchangeably with {\bf :=:} on input. \subsection{The ::= Operator} \label{lsetq} When assignments to matrix or array elements must be generated, many times the indices of the element must be evaluated first. The special operator {\bf ::=} can be used within a call to {\bf GENTRAN} to indicate that the indices of the matrix or array element on the left-hand side of the assignment are to be evaluated prior to translation. (This is the usual REDUCE assignment operator with an extra ``:'' on the left.) \begin{describe}{Example:} We wish to generate assignments which assign zeros to all elements on the main diagonal of M, an n x n matrix. \begin{verbatim} 10: FOR j := 1 : 8 DO 10: GENTRAN 10: M(j,j) ::= 0$ M(1,1)=0.0 M(2,2)=0.0 : : M(8,8)=0.0 \end{verbatim} \end{describe} {\bf LSETQ} may be used interchangeably with {\bf ::=} on input. \subsection{The ::=: Operator} \label{lrsetq} In applications in which evaluated expressions are to be assigned to array elements with evaluated subscripts, the {\bf ::=:} operator can be used. It is a combination of the {\bf ::=} and {\bf :=:} operators described in sections~\ref{rsetq} and ~\ref{lsetq}. \begin{describe}{Example:} The following matrix, M, has been derived symbolically: \begin{verbatim} ( A 0 -1 1) ( ) ( 0 B 0 0) ( ) ( -1 0 C -1) ( ) ( 1 0 -1 D) \end{verbatim} We wish to generate assignment statements for those elements on the main diagonal of the matrix. \begin{verbatim} 10: FOR j := 1 : 4 DO 10: GENTRAN 10: M(j,j) ::=: M(j,j)$ M(1,1)=A M(2,2)=B M(3,3)=C M(4,4)=D \end{verbatim} \end{describe} The alternative alphanumeric identifier associated with {\bf ::=:} is {\bf LRSETQ}. \section{Explicit Type Declarations} \label{explicit:type} Type declarations are automatically generated each time a subprogram heading is generated. Type declarations are constructed from information stored in the GENTRAN symbol table. The user can place entries into the symbol table explicitly through calls to the special GENTRAN function {\bf DECLARE}. \begin{describe}{Syntax:} {\bf \ \ DECLARE} {\it v1,v2,\dots\ ,vn} {\bf :} {\it type;} or \begin{tabular}{ll} {\bf DECLARE}\\ {\bf $<$$<$}\\ &{\it v11,v12,\dots\ ,v1n} {\bf :} {\it type1;}\\ &{\it v21,v22,\dots\ ,v2n} {\bf :} {\it type2;}\\ & :\\ & :\\ &{\it vn1,vnn,\dots\ ,vnn} {\bf :} {\it typen;}\\ {\bf $>$$>$}{\it ;} \end{tabular} \end{describe} \begin{describe}{Arguments:} Each {\it v1,v2,\dots\ ,vn} is a list of one or more variables (optionally subscripted to indicate array dimensions), or variable ranges (two letters separated by a ``-''). {\it v}'s are not evaluated unless given as arguments to {\bf EVAL}. Each {\it type} is a variable type in the target language. Each must be an atom, optionally preceded by the atom {\bf IMPLICIT}. {\it type}'s are not evaluated unless given as arguments to {\bf EVAL}. \end{describe} \begin{describe}{Side Effect:} Entries are placed in the symbol table for each variable or variable range declared in the call to this function. The function call itself is removed from the statement group being translated. Then after translation, type declarations are generated from these symbol table entries before the resulting executable statements are printed. \end{describe} \begin{describe}{Diagnostic Message:} \begin{verbatim} ***** INVALID SYNTAX \end{verbatim} \end{describe} \begin{describe}{Example:} \begin{verbatim} 1: GENTRAN 1: << 1: DECLARE 1: << 1: A-H, O-Z : IMPLICIT REAL; 1: M(4,4) : INTEGER 1: >>; 1: FOR I:=1:4 DO 1: FOR J:=1:4 DO 1: IF I=J 1: THEN M(I,J):=1 1: ELSE M(I,J):=0; 1: DECLARE I, J : INTEGER; 1: >>$ IMPLICIT REAL (A-H,O-Z) INTEGER M(4,4),I,J DO 25001 I=1,4 DO 25002 J=1,4 IF (I.EQ.J) THEN M(I,J)=1.0 ELSE M(I,J)=0.0 ENDIF 25002 CONTINUE 25001 CONTINUE \end{verbatim} \end{describe} The {\bf DECLARE} statement can also be used to declare subprogram types (i.e. {\bf SUBROUTINE} or {\bf FUNCTION}) for FORTRAN and RATFOR code, and function types for all four languages. \begin{describe}{Examples:} \begin{verbatim} 1: GENTRANLANG!* := 'RATFOR$ 2: GENTRAN 2: PROCEDURE FAC N; 2: BEGIN 2: DECLARE 2: << 2: FAC : FUNCTION; 2: FAC, N : INTEGER 2: >>; 2: F := FOR I:=1:N PRODUCT I; 2: DECLARE F, I : INTEGER; 2: RETURN F 2: END$ INTEGER FUNCTION FAC(N) INTEGER N,F,I { F=1 DO I=1,N F=F*I } RETURN(F) END 3: GENTRANLANG!* := 'C$ 4: GENTRAN 4: PROCEDURE FAC N; 4: BEGIN 4: DECLARE FAC, N, I, F : INTEGER; 4: F := FOR I:=1:N PRODUCT I; 4: RETURN F 4: END$ int FAC(N) int N; { int I,F; { F=1; for (I=1;I<=N;++I) F*=I; } return(F); } \end{verbatim} \end{describe} When generating code for subscripted variables (i.e., matrix and array elements), it is important to keep several things in mind. First of all, when a REDUCE array is declared with a declaration such as \begin{center} {\bf ARRAY A(}{\it n}{\bf )\$} \end{center} where {\it n} is a positive integer, {\bf A} is actually being declared to be of size {\bf n}+1. Each of the elements {\bf A(0), A(1), \dots\ , A(n)} can be used. However, a FORTRAN or RATFOR declaration such as \begin{center} {\bf DIMENSION A(}{\it n}{\bf )} \end{center} declares {\bf A} only to be of size {\bf n}. Only the elements {\bf A(1), A(2), \dots\ , A(n)} can be used. Furthermore, a C declaration such as \begin{center} {\bf FLOAT A[}{\it n}{\bf ];} \end{center} declares {\bf A} to be of size {\bf n} with elements referred to as {\bf A[0], A[1], \dots\ , A[}{\it n-1}{\bf ]}. To resolve these array size and subscripting conflicts, the user should remember the following: \begin{itemize} \item {\it All REDUCE array subscripts are translated literally.} Therefore it is the user's responsibility to be sure that array elements with subscript 0 are not translated into FORTRAN or RATFOR. \item Since C and PASCAL arrays allow elements with a subscript of 0, when an array is declared to be of size {\it n} by the user, {\it the actual generated type declaration will be of size n+1} so that the user can translate elements with subscripts from 0, and up to and including {\it n}. \end{itemize} \section{Implicit Type Declarations} \label{implicit:type} Some type declarations can be made automatically if the switch {\bf GETDECS} is {\bf ON}. In this case: \begin{enumerate} \item The indices of loops are automatically declared to be integers. \item There is a global variable {\bf DEFTYPE!*}, which is the default type given to objects. Subprograms, their parameters, and local scalar objects are automatically assigned this type. Note that types such as REAL*8 or DOUBLE PRECISION should not be used as, if {\bf DOUBLE} is on, then a default type of REAL will in fact be DOUBLE PRECISION anyway. \item If GENTRAN is used to translate a REDUCE procedure, then it assigns objects declared {\bf SCALAR} the type given by {\bf DEFTYPE!*}. Note that it is legal to use the commands {\bf INTEGER} and {\bf REAL} in the place of {\bf SCALAR}, which allows the user to specify an actual type. The procedure may also be given a return type, in which case that is used as the default. For example: \begin{verbatim} 2: on getdecs,gendecs$ 3: GENTRAN 3: real procedure f(x); 3: begin integer n;real y; 3: n := 4; 3: y := n/(1+x)^2; 3: return y; 3: end; REAL FUNCTION F(X) INTEGER N REAL X,Y N=4 Y=N/(1.0+X)**2 F=Y RETURN END \end{verbatim} \end{enumerate} \section{More about Type Declarations} \label{more:type} A check is made on output to ensure that all types generated are legal ones. This is necessary since {\bf DEFTYPE!*} can be set to anything. Note that {\bf DEFTYPE!*} ought normally to be given a simple type as its value, such as REAL, INTEGER, or COMPLEX, since this will always be translated into the corresponding type in the target language on output. An entry is removed from the symbol table once a declaration has been generated for it. The {\bf KEEPDECS} switch (by default {\bf OFF}) disables this, allowing a user to check the types of objects which GENTRAN has generated (useful if they are being generated automatically) \section{Comments and Literal Strings} \label{comments} Comments and other strings of characters can be inserted directly into the stream of generated code through a call to the special function {\bf LITERAL}. \begin{describe}{Syntax:} {\bf LITERAL} {\it arg1,arg2,\dots\ ,argn;} \end{describe} \begin{describe}{Arguments:} {\it arg1,arg2,\dots\ ,argn} is an argument list containing one or more {\it arg}'s, where each {\it arg} either is, or evaluates to, an atom. The atoms {\bf TAB!*} and {\bf CR!*} have special meanings. {\it arg}'s are not evaluated unless given as arguments to {\bf EVAL}. \end{describe} \begin{describe}{Side Effect:} This statement is replaced by the character sequence resulting from concatenation of the given atoms. Double quotes are stripped from all string type {\it arg}'s, and the reserved atoms {\bf TAB!*} and {\bf CR!*} are replaced by a tab to the current level of indentation, and an end-of-line character, respectively. \end{describe} \begin{describe}{Examples:} Suppose N has value 10. \begin{verbatim} 1: GENTRANLANG!* := 'FORTRAN$ 2: GENTRAN 2: << 2: LITERAL 2: "C",TAB!*,"--THIS IS A FORTRAN COMMENT--",CR!*, 2: "C",CR!*; 2: LITERAL 2: TAB!*,"DATA N/",EVAL(N),"/",CR!* 2: >>$ C --THIS IS A FORTRAN COMMENT-- C DATA N/10/ 3: GENTRANLANG!* := 'RATFOR$ 4: GENTRAN 4: FOR I:=1:N DO 4: << 4: LITERAL 4: TAB!*,"# THIS IS A RATFOR COMMENT",CR!*; 4: LITERAL 4: TAB!*,"WRITE(6,10) (M(I,J),J=1,N)",CR!*, 4: 10,TAB!*,"FORMAT(1X,10(I5,3X))",CR!* 4: >>$ DO I=1,N { # THIS IS A RATFOR COMMENT WRITE(6,10) (M(I,J),J=1,N) 10 FORMAT(1X,10(I5,3X)) } 5: GENTRANLANG!* := 'C$ 6: GENTRAN 6: << 6: X:=0; 6: LITERAL "/* THIS IS A",CR!*, 6: " C COMMENT */",CR!* 6: >>$ { X=0.0; /* THIS IS A C COMMENT */ } 7: GENTRANLANG!* := 'PASCAL$ 8: GENTRAN 8: << 8: X := SIN(Y); 8: LITERAL "{ THIS IS A PASCAL COMMENT }", CR!* 8: >>$ BEGIN X:=SIN(Y) { THIS IS A PASCAL COMMENT } END; \end{verbatim} \end{describe} \section{Expression Segmentation} \label{segmentation} Symbolic derivations can easily produce formulas that can be anywhere from a few lines to several pages in length. Such formulas can be translated into numerical assignment statements, but unless they are broken into smaller pieces they may be too long for a compiler to handle. (The maximum number of continuation lines for one statement allowed by most FORTRAN compilers is only 19.) Therefore GENTRAN contains a segmentation facility which automatically {\it segments}, or breaks down unreasonably large expressions. The segmentation facility generates a sequence of assignment statements, each of which assigns a subexpression to an automatically generated temporary variable. This sequence is generated in such a way that temporary variables are re-used as soon as possible, thereby keeping the number of automatically generated variables to a minimum. The facility can be turned on or off by setting the mode switch {\bf GENTRANSEG} accordingly (i.e., by calling the REDUCE function {\bf ON} or {\bf OFF} on it). The user can control the maximum allowable expression size by setting the variable {\bf MAXEXPPRINTLEN!*} to the maximum number of characters allowed in an expression printed in the target language (excluding spaces automatically printed by the formatter). The {\bf GENTRANSEG} switch is on initially, and {\bf MAXEXPPRINTLEN!*} is initialised to 800. \begin{describe}{Examples:} \begin{verbatim} 1: ON EXP$ 2: JUNK1 := (A+B+C+D)^2$ 3: MAXEXPPRINTLEN!* := 24$ 4: GENTRAN VAL :=: JUNK1$ T0=A**2+2.0*A*B T0=T0+2.0*A*C+2.0*A*D T0=T0+B**2+2.0*B*C T0=T0+2.0*B*D+C**2 VAL=T0+2.0*C*D+D**2 5: JUNK2 := JUNK1/(E+F+G)$ 6: MAXEXPPRINTLEN!* := 23$ 7: GENTRANLANG!* := 'C$ 8: GENTRAN VAL :=: JUNK2$ { T0=power(A,2)+2.0*A*B; T0+=2.0*A*C; T0=T0+2.0*A*D+power(B,2); T0+=2.0*B*C; T0=T0+2.0*B*D+power(C,2); T0=T0+2.0*C*D+power(D,2); VAL=T0/(exp(1.0)+F+G); } \end{verbatim} \end{describe} \subsection{Implicit Type Declarations} When the segmentation routine generates temporary variables, it places type declarations in the symbol table for those variables if possible. It uses the following rules to determine their type: \begin{itemize} \item[{(1)}] If the type of the variable to which the large expression is being assigned is already known (i.e., has been declared by the user), then the temporary variables will be declared to be of that same type. \item[{(2)}] If the global variable {\bf TEMPVARTYPE!*} has a non-NIL value, then the temporary variables are declared to be of that type. \item[{(3)}] Otherwise, the variables are not declared. \end{itemize} \begin{describe}{Example:} \begin{verbatim} 1: MAXEXPPRINTLEN!* := 20$ 2: TEMPVARTYPE!* := 'REAL$ 3: GENTRAN 3: << 3: DECLARE ISUM : INTEGER; 3: ISUM := II+JJ+2*KK+LL+10*MM+NN; 3: PROD := V(X,Y)*SIN(X)*COS(Y^2)*(X+Y+Z^2) 3: >>$ INTEGER ISUM,T0 REAL T1 T0=II+JJ+2.0*KK+LL ISUM=T0+10.0*MM+NN T1=V(X,Y)*SIN(X)*COS(Y**2) PROD=T1*(X+Y+Z**2) \end{verbatim} \end{describe} \section{Generation of Temporary Variable Names} \label{tempvars} As we have just seen, GENTRAN's segmentation module generates temporary variables and places type declarations in the symbol table for them whenever possible. Various other modules also generate variables and corresponding declarations. All of these modules call one special GENTRAN function each time they need a temporary variable name. This function is {\bf TEMPVAR}. There are situations in which it may be convenient for the user to be able to generate temporary variable names directly.\footnote{One such example is suppression of the simplification process to generate numerical code which is more efficient. See the example in section~\ref{tempvar:example}.} Therefore {\bf TEMPVAR} is a user-accessible function which may be called from both the algebraic and symbolic modes of REDUCE. \begin{describe}{Syntax:} {\bf TEMPVAR} {\it type} \end{describe} \begin{describe}{Argument:} {\it type} is an atom which either indicates the variable type in the target language (INTEGER, REAL, etc.), or is {\bf NIL} if the variable type is unknown. \end{describe} \begin{describe}{Side Effects:} {\bf TEMPVAR} creates temporary variable names by repeatedly concatenating the values of the global variables {\bf TEMPVARNAME!*} (which has a default value of {\bf T}) and {\bf TEMPVARNUM!*} (which is initially set to 0) and incrementing {\bf TEMPVARNUM!*} until a variable name is created which satisfies one of the following conditions: \begin{itemize} \item[{(1)}] It was not generated previously, and it has not been declared by the user. \item[{(2)}] It was previously generated to hold the same type of value that it must hold this time (e.g. INTEGER, REAL, etc.), and the value assigned to it previously is no longer needed. \end{itemize} If {\it type} is a non-NIL argument, or if {\it type} is {\bf NIL} and the global variable {\bf TEMPVARTYPE!*} (initially NIL) has been set to a non-NIL value, then a type entry for the generated variable name is placed in the symbol table. \end{describe} \begin{describe}{Returned Value:} {\bf TEMPVAR} returns an atom which can be used as a variable. \end{describe} Note: It is the user's responsibility to set {\bf TEMPVARNAME!*} and {\bf TEMPVARNUM!*} to values such that generated variable names will not clash with variables used elsewhere in the program unless those variables have been declared. \subsection{Marking Temporary Variables} In section~\ref{tempvars} we saw that a temporary variable name (of a certain type) can be regenerated when the value previously assigned to it is no longer needed. This section describes a function which {\it marks} a variable to indicate that it currently holds a significant value, and the next section describes functions which {\it unmark} variables to indicate that the values they hold are no longer significant. \begin{describe}{Syntax:} {\bf MARKVAR} {\it var} \end{describe} \begin{describe}{Argument:} {\it var} is an atom. \end{describe} \begin{describe}{Side Effects:} {\bf MARKVAR} sets a flag on {\it var}'s property list to indicate that {\it var} currently holds a significant value. \end{describe} \begin{describe}{Returned Value:} {\bf MARKVAR} returns {\it var}. \end{describe} \begin{describe}{Example:} The following matrix, M has been derived symbolically: \begin{verbatim} (X*(Y+Z) 0 X*Z) ( ) ( -X X+Y 0) ( ) ( X*Z 0 Z**2) \end{verbatim} We wish to replace each non-zero element by a generated variable name to prevent these expressions from being resubstituted into further calculations. (We will also record these substitutions in the numerical program we are constructing by generating assignment statements.)\footnote{ Note: {\bf MARKVAR} is a symbolic mode procedure. Therefore, the name of each variable whose value is to be passed to it from algebraic mode must appear in a {\bf SHARE} declaration. This tells REDUCE to share the variable's value between algebraic and symbolic modes.} \begin{verbatim} 9: SHARE var$ 10: FOR j := 1 : 3 DO 10: FOR k := 1 : 3 DO 10: IF M(j,k) NEQ 0 THEN 10: << 10: var := TEMPVAR(NIL); 10: MARKVAR var; 10: GENTRAN 10: EVAL(var) :=: M(j,k); 10: M(j,k) := var 10: >>$ T0=X*(Y+Z) T1=X*Z T2=-X T3=X+Y T4=X*Z T5=Z**2 \end{verbatim} Now matrix M contains the following entries: \begin{verbatim} (T0 0 T1) ( ) (T2 T3 0) ( ) (T4 0 T5) \end{verbatim} \end{describe} \subsection{Unmarking Temporary Variables} After the value assigned to a temporary variable has been used in the numerical program and is no longer needed, the variable name can be {\it unmarked} with the {\bf UNMARKVAR} function. \begin{describe}{Syntax:} {\bf UNMARKVAR} {\it var;} \end{describe} \begin{describe}{Argument:} {\it var} is an atom (variable name) or an expression containing one or more variable names. \end{describe} \begin{describe}{Side Effect:} {\bf UNMARKVAR} resets flags on the property lists of all variable names in {\it var} to indicate that they do not hold significant values any longer. \end{describe} \section{Enabling and Disabling Generation of Type Declarations} \label{control:type} GENTRAN maintains a symbol table of variable type and dimension information. It adds information to the symbol table by processing user-supplied calls to the {\bf DECLARE} function (see Section~\ref{explicit:type}) and as a side effect of generating temporary variable names (see Sections~\ref{segmentation} and \ref{tempvars}). All information is stored in the symbol table until GENTRAN is ready to print formatted numerical code. Since programming languages such as FORTRAN require that type declarations appear before executable statements, GENTRAN automatically extracts all relevant type information and prints it in the form of type declarations before printing executable statements. This feature is useful when the entire body of a (sub)program is generated at one time: in this case, type declarations are printed before any executable code. However, if the user chooses to generate code in pieces, the resulting code may have type declarations interleaved with executable code. For this reason, the user may turn the {\bf GENDECS} mode switch on or off, depending on whether or not s/he chooses to use this feature. In the following we re-examine the example of Section 2.9.1: \begin{describe}{Example:} \begin{verbatim} 1: MAXEXPPRINTLEN!* := 20$ 2: TEMPVARTYPE!* := 'REAL!*8$ 3: GENTRAN 3: << 3: DECLARE ISUM : INTEGER; 3: ISUM := II+JJ+2*KK+LL+10*MM+NN 3: >>$ INTEGER ISUM,T0 T0=II+JJ+2*KK+LL ISUM=T0+10*MM+NN 4: GENTRAN PROD := V(X,Y)*SIN(X)*COS(Y^2)*(X+Y+Z^2)$ REAL*8 T2 T2=V(X,Y)*SIN(REAL(X))*COS(REAL(Y**2)) PROD=T2*(X+Y+Z**2) 5: OFF GENDECS$ 6: GENTRAN 6: << 6: DECLARE ISUM : INTEGER; 6: ISUM := II+JJ+2*KK+LL+10*MM+NN 6: >>$ T0=II+JJ+2*KK+LL ISUM=T0+10*MM+NN 7: GENTRAN PROD := V(X,Y)*SIN(X)*COS(Y^2)*(X+Y+Z^2)$ T2=V(X,Y)*SIN(REAL(X))*COS(REAL(Y**2)) PROD=T2*(X+Y+Z**2) \end{verbatim} \end{describe} In Section~\ref{template:type} we will explain how to further control the generation of type declarations. \section{Complex Numbers} \label{complex} With the switch {\bf COMPLEX} set {\bf ON}, GENTRAN will generate the correct representation for a complex number in the given precision provided that: \begin{enumerate} \item The current language supports a complex data type (if it doesn't then an error results); \item The complex quantity is evaluated by REDUCE to give an object of the correct domain; i.e. \begin{verbatim} GENTRAN x:=: 1+i; GENTRAN x:= eval 1+i; z := 1+i; GENTRAN x:=: z; \end{verbatim} will all generate the correct result, as will their Symbolic mode equivalents, while: \begin{verbatim} GENTRAN x := 1+i; \end{verbatim} will not. \end{enumerate} \section{Intrinsic Functions} \label{intrinsic} A warning is issued if a standard REDUCE function is encountered which does not have an intrinsic counterpart in the target language (e.g. {\it cot\/}, {\it sec\/} etc.). Output is not halted in case this is a user--supplied function, either via a REDUCE definition or within a GENTRAN template. The types of intrinsic FORTRAN functions are coerced to reals (in the correct precision) as the following examples demonstrate: \begin{verbatim} 19: GENTRAN x:=sin(0)$ X=SIN(0.0) 20: GENTRAN x:=cos(A)$ X=COS(REAL(A)) 21: ON DOUBLE$ 22: GENTRAN x := log(1)$ X=DLOG(1.0D0) 23: GENTRAN x := exp(B)$ X=DEXP(DBLE(B)) 24: GENTRAN DECLARE <<b:real>>$ 25: GENTRAN x := exp(B)$ X=DEXP(B) \end{verbatim} \section{Miscellaneous} \subsection{MAKECALLS} A statement like: \begin{verbatim} GENTRAN x^2+1$ \end{verbatim} will yield the result: \begin{verbatim} X**2+1 \end{verbatim} but, under normal circumstances, a statement like: \begin{verbatim} GENTRAN sin(x)$ \end{verbatim} will yield the result: \begin{verbatim} CALL SIN(X) \end{verbatim} The switch {\bf MAKECALLS} (OFF by default) will make GENTRAN yield \begin{verbatim} SIN(X) \end{verbatim} This is useful if you don't know in advance what the form of the expression which you are translating is going to be. \subsection{E} When GENTRAN encounters $e$ it translates it into EXP(1), and when GENTRAN encounters $e^x$ it is translated to EXP(X). This is then translated into the correct statement in the given language and precision. Note that it is still possible to do something like: \begin{verbatim} GENTRAN e:=:e; \end{verbatim} and get the correct result. \chapter{TEMPLATE PROCESSING} In some code generation applications pieces of the target numerical program are known in advance. A {\it template} file containing a program outline is supplied by the user, and formulas are derived in REDUCE, converted to numerical code, and inserted in the corresponding places in the program outline to form a complete numerical program. A template processor is provided by GENTRAN for use in these applications. \section{The Template Processing Command} \label{templates} \begin{describe}{Syntax:} {\bf GENTRANIN} {\it f1,f2,\dots\ ,fm} [{\bf OUT} {\it f1,f2,\dots\ ,fn\/}]{\it ;} \end{describe} \begin{describe}{Arguments:} {\it f1,f2,\dots\ ,fm\/} is an argument list containing one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom}& = &a template (input) file\\ {\bf T}& = &the terminal\\ \end{tabular} \end{center} {\it f1,f2,\dots\ ,fn\/} is an optional argument list containing one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom}& = &an output file\\ {\bf T}& = &the terminal\\ {\bf NIL}& = &the current output file(s)\\ {\bf ALL!*}& = &all files currently open for output by GENTRAN (see Sect. 4)\\ \end{tabular} \end{center} \end{describe} \begin{describe}{Side Effects:} {\bf GENTRANIN} processes each template file {\it f1,f2,\dots\ ,fm} sequentially. A template file may contain any number of parts, each of which is either an active or an inactive part. All active parts start with the character sequence {\bf ;BEGIN;} and end with {\bf ;END;}. The end of the template file is indicated by an extra {\bf ;END;} character sequence. Inactive parts of template files are assumed to contain code in the target language (FORTRAN, RATFOR, PASCAL or C, depending on the value of the global variable {\bf GENTRANLANG!*}). All inactive parts are copied to the output. Comments delimited by the appropriate characters, \begin{center} \begin{tabular}{lll} &{\bf C} \dots\ $<$cr$>$ & for FORTRAN (beginning in the first column),\\ &{\bf \#} \dots\ $<$cr$>$ & for RATFOR, and\\ &{\bf /*} \dots\ {\bf */} & for C\\ &{\bf \{} \dots\ {\bf \}} or {\bf *(} \dots\ {\bf )*} & for PASCAL\\ \end{tabular} \end{center} are also copied in their entirety to the output. Thus the character sequences {\bf ;BEGIN;} and {\bf ;END;} have no special meanings within comments. Active parts may contain any number of REDUCE expressions, statements, and commands. They are not copied directly to the output. Instead, they are given to REDUCE for evaluation in algebraic mode\footnote{ Active parts are evaluated in algebraic mode unless the mode is explicitly changed to symbolic from within the active part itself. This is true no matter which mode the system was in when the template processor was called.}. All output generated by each evaluation is sent to the output file(s). Returned values are only printed on the terminal. Active parts will most likely contain calls to {\bf GENTRAN} to generate code. This means that the result of processing a template file will be the original template file with all active parts replaced by generated code. If {\bf OUT} {\it f1,f2,\dots\ ,fn} is not given, generated code is simply written to the current-output file. However, if {\bf OUT} {\it f1,f2,\dots\ ,fn} is given, then the current-output file is temporarily overridden. Generated code is written to each file represented by {\it f1,f2,\dots\ ,fn} for this command only. Files which were open prior to the call to {\bf GENTRANIN} will remain open after the call, and files which did not exist prior to the call will be created, opened, written to, and closed. The output-stack will be exactly the same both before and after the call. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRANIN} returns the names of all files written to by this command. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** NONEXISTENT INPUT FILE ***** TEMPLATE FILE ALREADY OPEN FOR INPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \begin{describe}{Example:} Suppose we wish to generate a FORTRAN subprogram to compute the determinant of a 3 x 3 matrix. We can construct a template file with an outline of the FORTRAN subprogram and REDUCE and GENTRAN commands to fill it in: Contents of file det.tem: \end{describe} \begin{framedverbatim} REAL FUNCTION DET(M) REAL M(3,3) ;BEGIN; OPERATOR M$ MATRIX MM(3,3)$ MM := MAT( (M(1,1),M(1,2),M(1,3)), (M(2,1),M(2,2),M(2,3)), (M(3,1),M(3,2),M(3,3)) )$ GENTRAN DET :=: DET(MM)$ ;END; RETURN END ;END; \end{framedverbatim} \begin{describe}{} Now we can generate a FORTRAN subprogram with the following REDUCE session: \begin{verbatim} 1: GENTRANLANG!* := 'FORTRAN$ 2: GENTRANIN 2: "det.tem" 2: OUT "det.f"$ \end{verbatim} Contents of file det.f: \end{describe} \begin{framedverbatim} REAL FUNCTION DET(M) REAL M(3,3) DET=M(3,3)*M(2,2)*M(1,1)-(M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1 . ,1))+M(3,2)*M(2,1)*M(1,3)+M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1 . ,3)) RETURN END \end{framedverbatim} \section{Copying Files into Template Files} \label{copy:template} Template files can be copied into other template files with recursive calls to {\bf GENTRANIN} ; i.e., by calling {\bf GENTRANIN} from the active part of a template file. For example, suppose we wish to copy the contents of a file containing a subprogram into a file containing a main program. We will call {\bf GENTRANIN} to do the copying, so the subprogram file must have {\bf ;END;} on its last line: Contents of file det.tem: \begin{framedverbatim} REAL FUNCTION DET(M) REAL M(3,3) DET=M(3,3)*M(2,2)*M(1,1)-(M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1 . ,1))+M(3,2)*M(2,1)*M(1,3)+M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1 . ,3)) RETURN END ;END; \end{framedverbatim} Now the template file for the main program can be constructed with an active part which will include file det.tem: Contents of file main.tem: \begin{framedverbatim} C C MAIN PROGRAM C REAL M(3,3),DET WRITE(6,*) 'ENTER 3 x 3 MATRIX' DO 100 I=1,3 READ(5,*) (M(I,J),J=1,3) 100 CONTINUE WRITE(6,*) ' DET = ', DET(M) STOP END C C DETERMINANT CALCULATION C ;BEGIN; GENTRANIN "det.tem"$ ;END; ;END; \end{framedverbatim} The following REDUCE session will create the file main.f: \begin{verbatim} 1: GENTRANIN 1: "main.tem" 1: OUT "main.f"$ \end{verbatim} Contents of file main.f: \begin{framedverbatim} C C MAIN PROGRAM C REAL M(3,3),DET WRITE(6,*) 'ENTER 3 x 3 MATRIX' DO 100 I=1,3 READ(5,*) (M(I,J),J=1,3) 100 CONTINUE WRITE(6,*) ' DET = ', DET(M) STOP END C C DETERMINANT CALCULATION C REAL FUNCTION DET(M) REAL M(3,3) DET=M(3,3)*M(2,2)*M(1,1)-(M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1 . ,1))+M(3,2)*M(2,1)*M(1,3)+M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1 . ,3)) RETURN END \end{framedverbatim} \section{The Template File Stack} \label{template:stack} The REDUCE {\bf IN} command takes one or more file names as arguments. REDUCE reads each of the given files and executes all statements and commands, any of which may be another {\bf IN} command. A stack of input file names is maintained by REDUCE to allow recursive invocation of the {\bf IN} command. Similarly, a stack of template file names is maintained by GENTRAN to facilitate recursive invocation of the template processor. Section~\ref{copy:template} showed that the {\bf GENTRANIN} command can be called recursively to copy files into other files. This section shows that template files which are copied into other template files can also contain active parts, and thus the whole code generation process can be invoked recursively. We can generalise the example of section~\ref{copy:template} by generating code recursively. We can extend it to generate code which will compute entries of the inverse matrix, also. Suppose we have created the file init.red, which contains REDUCE commands to create an {\it n}x{\it n} matrix MM and initialise its entries to M(1,1), M(1,2),~\dots~, M({\it n}, {\it n}), for some user-entered value of {\it n}: Contents of file init.red: \begin{framedverbatim} OPERATOR M$ MATRIX MM(n,n)$ FOR J := 1 : n DO FOR K := 1 : n DO MM(J,K) := M(J,K)$ END$ \end{framedverbatim} We have also created template files det.tem and inv.tem which contain outlines of FORTRAN subprograms to compute the determinant and inverse of an {\it n}x{\it n} matrix, respectively: Contents of file det.tem: \begin{framedverbatim} REAL FUNCTION DET(M) ;BEGIN; GENTRAN << DECLARE M(EVAL(n),EVAL(n)) : REAL; DET :=: DET(MM) >>$ ;END; RETURN END ;END; \end{framedverbatim} Contents of file inv.tem: \begin{framedverbatim} SUBROUTINE INV(M,MINV) ;BEGIN; GENTRAN << DECLARE M(EVAL(n),EVAL(n)), MINV(EVAL(n),EVAL(n)) : REAL; MINV :=: MM^(-1) >>$ ;END; RETURN END ;END; \end{framedverbatim} Now we can construct a template file with a generalised version of the main program given in section~\ref{copy:template} and can place {\bf GENTRANIN} commands in this file to generate code recursively from the template files det.tem and inv.tem: Contents of file main.tem: \begin{framedverbatim} C C MAIN PROGRAM C ;BEGIN; GENTRAN << DECLARE << M(EVAL(n),EVAL(n)), DET, MINV(EVAL(n),EVAL(n)) : REAL; N : INTEGER >>; LITERAL TAB!*, "DATA N/", EVAL(n), "/", CR!* >>$ ;END; WRITE(6,*) 'ENTER ', N, 'x', N, ' MATRIX' DO 100 I=1,N READ(5,*) (M(I,J),J=1,N) 100 CONTINUE WRITE(6,*) ' DET = ', DET(M) WRITE(6,*) ' INVERSE MATRIX:' CALL INV(M,MINV) DO 200 I=1,N WRITE(6,*) (MINV(I,J),J=1,N) 200 CONTINUE STOP END C C DETERMINANT CALCULATION C ;BEGIN; GENTRANIN "det.tem"$ ;END; C C INVERSE CALCULATION C ;BEGIN; GENTRANIN "inv.tem"$ ;END; ;END; \end{framedverbatim} The following REDUCE session will create the file main.f: \begin{verbatim} 1: n := 3$ 2: IN "init.red"$ 3: GENTRANLANG!* := 'FORTRAN$ 4: GENTRANIN 4: "main.tem" 4: OUT "main.f"$ \end{verbatim} Contents of file main.f: \begin{framedverbatim} C C MAIN PROGRAM C REAL M(3,3),DET,MINV(3,3) INTEGER N DATA N/3/ WRITE(6,*) 'ENTER ', N, 'x', N, ' MATRIX' DO 100 I=1,N READ(5,*) (M(I,J),J=1,N) 100 CONTINUE WRITE(6,*) ' DET = ', DET(M) WRITE(6,*) ' INVERSE MATRIX:' CALL INV(M,MINV) DO 200 I=1,N WRITE(6,*) (MINV(I,J),J=1,N) 200 CONTINUE STOP END C C DETERMINANT CALCULATION C REAL FUNCTION DET(M) REAL M(3,3) DET=M(3,3)*M(2,2)*M(1,1)-(M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1 . ,1))+M(3,2)*M(2,1)*M(1,3)+M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1 . ,3)) RETURN END C C INVERSE CALCULATION C SUBROUTINE INV(M,MINV) REAL M(3,3),MINV(3,3) MINV(1,1)=(M(3,3)*M(2,2)-(M(3,2)*M(2,3)))/(M(3,3)*M(2,2)*M(1,1)-(M . (3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3)+ . M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(1,2)=(-(M(3,3)*M(1,2))+M(3,2)*M(1,3))/(M(3,3)*M(2,2)*M(1,1)-( . M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3) . +M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(1,3)=(M(2,3)*M(1,2)-(M(2,2)*M(1,3)))/(M(3,3)*M(2,2)*M(1,1)-(M . (3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3)+ . M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(2,1)=(-(M(3,3)*M(2,1))+M(3,1)*M(2,3))/(M(3,3)*M(2,2)*M(1,1)-( . M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3) . +M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(2,2)=(M(3,3)*M(1,1)-(M(3,1)*M(1,3)))/(M(3,3)*M(2,2)*M(1,1)-(M . (3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3)+ . M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(2,3)=(-(M(2,3)*M(1,1))+M(2,1)*M(1,3))/(M(3,3)*M(2,2)*M(1,1)-( . M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3) . +M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(3,1)=(M(3,2)*M(2,1)-(M(3,1)*M(2,2)))/(M(3,3)*M(2,2)*M(1,1)-(M . (3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3)+ . M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(3,2)=(-(M(3,2)*M(1,1))+M(3,1)*M(1,2))/(M(3,3)*M(2,2)*M(1,1)-( . M(3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3) . +M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) MINV(3,3)=(M(2,2)*M(1,1)-(M(2,1)*M(1,2)))/(M(3,3)*M(2,2)*M(1,1)-(M . (3,3)*M(2,1)*M(1,2))-(M(3,2)*M(2,3)*M(1,1))+M(3,2)*M(2,1)*M(1,3)+ . M(3,1)*M(2,3)*M(1,2)-(M(3,1)*M(2,2)*M(1,3))) RETURN END \end{framedverbatim} This is an example of a modular approach to code generation; separate subprogram templates are given in separate files. Furthermore, the template files are general; they can be used for matrices of any predetermined size. Therefore, we can easily generate different subprograms to handle matrices of different sizes from the same template files simply by assigning different values to {\it n}, and reloading the file init.red. \section{Template Processing and Generation of Type Declarations} \label{template:type} In Section~\ref{control:type} we described the {\bf GENDECS} flag. We explained that type declarations are not generated when this flag is turned off. Now that the concept of template processing has been explained, it is appropriate to continue our discussion of generation of type declarations. When the {\bf GENDECS} flag is off, type declaration information is not simply discarded --- it is still maintained in the symbol table. Only the automatic extraction of this information in the form of declarations is disabled. When the {\bf GENDECS} flag is turned off, all type information associated with a specific subprogram can be retrieved in the form of generated declarations by calling the {\bf GENDECS} function with the subprogram name as argument. The template processor recognizes function and subroutine headings. It always keeps track of the name of the subprogram it is processing. Therefore, the declarations associated with a particular subprogram {\it subprogname} can be generated with a call to {\bf GENDECS} as follows: \begin{center} {\bf GENDECS} {\it subprogname}\$ \end{center} By using the {\bf GENDECS} flag and function together with the template processing facility, it is possible to have type information inserted into the symbol table during a first pass over a template file, and then to have it extracted during a second pass. Consider the following example in which the original template file is transformed into an intermediate template during the first pass, and then into the final file of FORTRAN code during the second pass: Contents of file junk.tem: \begin{framedverbatim} ;BEGIN; MAXEXPPRINTLEN!* := 50$ OFF GENDECS$ ;END; SUBROUTINE CALC(X,Y,Z,A,B,RES) ;BEGIN; GENTRAN LITERAL ";BEGIN;", CR!*, "GENDECS CALC$", CR!*, ";END;", CR!*$ ;END; X=3.75 Y=-10.2 Z=16.473 ;BEGIN; GENTRAN << DECLARE X,Y,Z,A,B,RES : REAL; RES :=: (X + Y + Z)^3*(A + B)^2 >>$ ;END; RETURN END ;BEGIN; GENTRAN LITERAL ";END;", CR!*$ ;END; ;END; \end{framedverbatim} Invocation of the template processor on this file produces an intermediate template file: \begin{verbatim} 1: GENTRANIN 1: "junk.tem" 1: OUT "#junk.tem"$ \end{verbatim} Contents of file \#junk.tem: \begin{framedverbatim} SUBROUTINE CALC(X,Y,Z,A,B,RES) ;BEGIN; GENDECS CALC$ ;END; X=3.75 Y=-10.2 Z=16.473 T0=A**2*X**3+3.0*A**2*X**2*Y T0=T0+3.0*A**2*X**2*Z+3.0*A**2*X*Y**2 T0=T0+6.0*A**2*X*Y*Z+3.0*A**2*X*Z**2 T0=T0+A**2*Y**3+3.0*A**2*Y**2*Z T0=T0+3.0*A**2*Y*Z**2+A**2*Z**3 T0=T0+2.0*A*B*X**3+6.0*A*B*X**2*Y T0=T0+6.0*A*B*X**2*Z+6.0*A*B*X*Y**2 T0=T0+12.0*A*B*X*Y*Z+6.0*A*B*X*Z**2 T0=T0+2.0*A*B*Y**3+6.0*A*B*Y**2*Z T0=T0+6.0*A*B*Y*Z**2+2.0*A*B*Z**3 T0=T0+B**2*X**3+3.0*B**2*X**2*Y T0=T0+3.0*B**2*X**2*Z+3.0*B**2*X*Y**2 T0=T0+6.0*B**2*X*Y*Z+3.0*B**2*X*Z**2 T0=T0+B**2*Y**3+3.0*B**2*Y**2*Z RES=T0+3.0*B**2*Y*Z**2+B**2*Z**3 RETURN END ;END; \end{framedverbatim} Another pass of the template processor produced the final file of FORTRAN code: \begin{verbatim} 2: GENTRANIN 2: "#junk.tem" 2: OUT "junk.f"$ \end{verbatim} Contents of file junk.f: \begin{framedverbatim} SUBROUTINE CALC(X,Y,Z,A,B,RES) REAL X,Y,Z,A,B,RES,T0 X=3.75 Y=-10.2 Z=16.473 T0=A**2*X**3+3.0*A**2*X**2*Y T0=T0+3.0*A**2*X**2*Z+3.0*A**2*X*Y**2 T0=T0+6.0*A**2*X*Y*Z+3.0*A**2*X*Z**2 T0=T0+A**2*Y**3+3.0*A**2*Y**2*Z T0=T0+3.0*A**2*Y*Z**2+A**2*Z**3 T0=T0+2.0*A*B*X**3+6.0*A*B*X**2*Y T0=T0+6.0*A*B*X**2*Z+6.0*A*B*X*Y**2 T0=T0+12.0*A*B*X*Y*Z+6.0*A*B*X*Z**2 T0=T0+2.0*A*B*Y**3+6.0*A*B*Y**2*Z T0=T0+6.0*A*B*Y*Z**2+2.0*A*B*Z**3 T0=T0+B**2*X**3+3.0*B**2*X**2*Y T0=T0+3.0*B**2*X**2*Z+3.0*B**2*X*Y**2 T0=T0+6.0*B**2*X*Y*Z+3.0*B**2*X*Z**2 T0=T0+B**2*Y**3+3.0*B**2*Y**2*Z RES=T0+3.0*B**2*Y*Z**2+B**2*Z**3 RETURN END \end{framedverbatim} \section{Referencing Subprogram and Parameter Names} In some code generation applications in which template processing is used, it is useful to be able to reference the names of the parameters given in the subprogram header. For this reason, the special symbols {\bf !\$1}, {\bf !\$2},~\dots, {\bf !\${\it n}}, where {\it n} is the number of parameters, can be used in computations and code generation commands in active parts of template files. Each of these symbols will be replaced by the corresponding parameter name when code is generated. In addition, the special symbol {\bf !\$0} will be replaced by the subprogram name. This is useful when FORTRAN or RATFOR functions are being generated. Finally, the special global variable {\bf !\$!\#} is bound to the number of parameters in the subprogram header. \chapter{OUTPUT REDIRECTION} Many examples given thus far in this manual have sent all generated code to the terminal screen. In actual code generation applications, however, code must be sent to a file which will be compiled at a later time. This section explains methods of redirecting code to a file as it is generated. Any number of output files can be open simultaneously, and generated code can be sent to any combination of these open files. \section{File Selection Commands} \label{file:selection} REDUCE provides the user with two file handling commands for output redirection: {\bf OUT} and {\bf SHUT}. The {\bf OUT} command takes a single file name as argument and directs all REDUCE output to that file from then on, until another {\bf OUT} changes the output file, or {\bf SHUT} closes it. Output can go to only one file at a time, although many can be open. If the file has previously been used for output during the current job and not {\bf SHUT}, then the new output is appended onto the end of the file. Any existing file is erased before its first use for output in a job. To output on the terminal without closing the output file, the reserved file name {\bf T} (for terminal) may be used. The REDUCE {\bf SHUT} command takes a list of names of files which have been previously opened via an {\bf OUT} command and closes them. Most systems require this action by the user before he ends the REDUCE job; otherwise the output may be lost. If a file is {\bf SHUT} and a further {\bf OUT} command is issued for the same file, the file is erased before the new output is written. If it is the current output file that is {\bf SHUT}, output will switch to the terminal. These commands are suitable for most applications in which REDUCE output must be saved. However, they have two deficiencies when considered for use in code generation applications. First, they are inconvenient. {\bf OUT} tells REDUCE to direct {\it all\/} output to a specified file. Thus in addition to output written as side effects of functions, returned values are also written to the file (unless the user is careful to terminate all statements and commands with a {\bf \$}, in which case only output produced by side effects is written). If code generation is to be accomplished interactively; i.e., if algebraic computations and code generation commands are interleaved, then {\bf OUT} {\it filename\/}{\bf \$} must be issued before every group of code generation requests, and {\bf OUT T\$} must be issued after every group. Secondly, the {\bf OUT} command does not allow output to be sent to two or more files without reissuing the {\bf OUT} with another file name. In an effort to remove these deficiencies and make the code generation commands flexible and easy to use, separate file handling commands are provided by GENTRAN which redirect generated code {\it only}. The {\bf GENTRANOUT} and {\bf GENTRANSHUT} commands are identical to the REDUCE {\bf OUT} and {\bf SHUT} commands with the following exceptions: \begin{itemize} \item {\bf GENTRANOUT} and {\bf GENTRANSHUT} redirect {\it only\/} code which is printed as a side effect of GENTRAN commands. \item {\bf GENTRANOUT} allows more than one file name to be given to indicate that generated code is to be sent to two or more files. (It is particularly convenient to be able to have generated code sent to the terminal screen and one or more file simultaneously.) \item {\bf GENTRANOUT} does not automatically erase existing files; it prints a warning message on the terminal and asks the user whether the existing file should be erased or the whole command be aborted. \end{itemize} The next two subsections describe these commands in detail. \subsection{GENTRANOUT} \begin{describe}{Syntax:} {\bf GENTRANOUT} {\it f1,f2,\dots\ ,fn;} \end{describe} \begin{describe}{Arguments:} {\it f1,f2,\dots\ ,fn\/} is a list of one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{center} \end{describe} \begin{describe}{Side Effects:} GENTRAN maintains a list of files currently open for output by GENTRAN {\it only}. {\bf GENTRANOUT} inserts each file name represented by {\it f1,f2,\dots\ ,fn\/} into that list and opens each one for output. It also resets the current output file(s) to be all files in {\it f1,f2,\dots\ ,fn}. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRANOUT} returns the list of files represented by {\it f1,f2,\dots\ ,fn\/}; i.e., the current output file(s) after the command has been executed. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \begin{describe}{Examples:} Output file list: \begin{verbatim} current-output | v +------+ | T | +------+ \end{verbatim} \begin{verbatim} 1: GENTRANOUT "f1"; "f1" \end{verbatim} Output file list: \begin{verbatim} current-output | v +------+------+ | T | "f1" | +------+------+ \end{verbatim} \begin{verbatim} 2: GENTRANOUT "f2"; "f2" \end{verbatim} Output file list: \begin{verbatim} current-output | v +------+------+------+ | T | "f1" | "f2" | +------+------+------+ \end{verbatim} \begin{verbatim} 3: GENTRANOUT T,"f3"; {T,"f3"} \end{verbatim} Output file list: \begin{verbatim} +--------------------+------current-output | | v v +------+------+------+------+ | T | "f1" | "f2" | "f3" | +------+------+------+------+ \end{verbatim} \begin{verbatim} 4: GENTRANOUT "f1"; "f1" \end{verbatim} Output file list: \begin{verbatim} current-output | v +------+------+------+------+ | T | "f1" | "f2" | "f3" | +------+------+------+------+ \end{verbatim} \begin{verbatim} 5: GENTRANOUT NIL,"f4"; {"f1","f4"} \end{verbatim} Output file list: \begin{verbatim} +--------------------+------current-output | | v v +------+------+------+------+------+ | T | "f1" | "f2" | "f3" | "f4" | +------+------+------+------+------+ \end{verbatim} \begin{verbatim} 6: GENTRANOUT ALL!*; {"f1","f2","f3","f4"} \end{verbatim} Output file list: \begin{verbatim} +------+------+------+------current-output | | | | v v v v +------+------+------+------+------+ | T | "f1" | "f2" | "f3" | "f4" | +------+------+------+------+------+ \end{verbatim} \end{describe} \subsection{GENTRANSHUT} \begin{describe}{Syntax:} {\bf GENTRANSHUT} {\it f1,f2,\dots\ ,fn;\/} \end{describe} \begin{describe}{Arguments:} {\it f1,f2,\dots\ ,fn\/} is a list of one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{center} \end{describe} \begin{describe}{Side Effects:} {\bf GENTRANSHUT} creates a list of file names from {\it f1,f2,\dots\ ,fn}, deletes each from the output file list, and closes the corresponding files. If (all of) the current output file(s) are closed, then the current output file is reset to the terminal. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRANSHUT} returns the current output file(s) after the command has been executed. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** FILE NOT OPEN FOR OUTPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \begin{describe}{Examples:} Output file list: \begin{verbatim} current-output ------+------+-------------------+ | | | v v v +------+------+------+------+------+------+------+------+ | T | "f1" | "f2" | "f3" | "f4" | "f5" | "f6" | "f7" | +------+------+------+------+------+------+------+------+ \end{verbatim} \begin{verbatim} 1: GENTRANSHUT "f1","f2","f7"; {"f3","f4"} \end{verbatim} \begin{verbatim} Output file list: +------+--------------current-output | | v v +------+------+------+------+------+ | T | "f3" | "f4" | "f5" | "f6" | +------+------+------+------+------+ \end{verbatim} \begin{verbatim} 2: GENTRANSHUT NIL; T \end{verbatim} Output file list: \begin{verbatim} current-output | v +------+------+------+ | T | "f5" | "f6" | +------+------+------+ \end{verbatim} \begin{verbatim} 3: GENTRANSHUT ALL!*; T \end{verbatim} Output file list: \begin{verbatim} current-output | v +------+ | T | +------+ \end{verbatim} \end{describe} \section{The Output File Stack} Section~\ref{file:selection} explained the {\bf GENTRANOUT} and {\bf GENTRANSHUT} commands which are very similar to the REDUCE {\bf OUT} and {\bf SHUT} commands but redirect {\it only code generated as side effects of GENTRAN commands\/} to files. This section describes another pair of file handling commands provided by GENTRAN. In some code generation applications it may be convenient to be able to send generated code to one (set of) file(s), then temporarily send code to another (set of) file(s), and later resume sending generated code to the first (set of) file(s). In other words, it is convenient to think of the output files as being arranged in a stack which can be pushed whenever new files are to be written to temporarily, and popped whenever previously written-to files are to be appended onto. {\bf GENTRANPUSH} and {\bf GENTRANPOP} enable the user to manipulate a stack of open output files in these ways. {\bf GENTRANPUSH} simply pushes a (set of) file(s) onto the stack and opens each one that is not already open for output. {\bf GENTRANPOP} deletes the top-most occurrence of the given file(s) from the stack and closes each one that is no longer in the stack. The stack is initialised to one element: the terminal. This element is always on the bottom of the stack, and thus, is the default output file. The current output file is always the file(s) on top of the stack. \subsection{GENTRANPUSH} \begin{describe}{Syntax:} {\bf GENTRANPUSH} {\it f1,f2,\dots\ ,fn;} \end{describe} \begin{describe}{Arguments:} {\it f1,f2,\dots\ ,fn\/} is a list of one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{center} \end{describe} \begin{describe}{Side Effects:} {\bf GENTRANPUSH} creates a list of file name(s) represented by {\it f1,f2,\dots\ ,fn\/} and pushes that list onto the output stack. Each file in the list that is not already open for output is opened at this time. The current output file is reset to this new element on the top of the stack. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRANPUSH} returns the list of files represented by {\it f1,f2,\dots\ ,fn\/}; i.e., the current output file(s) after the command has been executed. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \begin{describe}{Examples:} Output stack: \begin{verbatim} +----------------+ | T | <== current-output +----------------+ \end{verbatim} \begin{verbatim} 1: GENTRANPUSH "f1"; "f1" \end{verbatim} Output stack: \begin{verbatim} +----------------+ | "f1" | <== current-output | T | +----------------+ \end{verbatim} \begin{verbatim} 2: GENTRANPUSH "f2","f3"; {"f2","f3"} \end{verbatim} Output stack: \begin{verbatim} +----------------+ | "f2" "f3" | <== current-output | "f1" | | T | +----------------+ \end{verbatim} \begin{verbatim} 3: GENTRANPUSH NIL,T; {"f2","f3",T} \end{verbatim} Output stack: \begin{verbatim} +----------------+ | "f2" "f3" T | <== current-output | "f2" "f3" | | "f1" | | T | +----------------+ \end{verbatim} \begin{verbatim} 4: GENTRANPUSH "f1"; "f1" \end{verbatim} Output stack: \begin{verbatim} +----------------+ | "f1" | <== current-output | "f2" "f3" T | | "f2" "f3" | | "f1" | | T | +----------------+ \end{verbatim} \begin{verbatim} 5: GENTRANPUSH ALL!*; {"f1","f2","f3"} \end{verbatim} Output stack: \begin{verbatim} +----------------+ | "f1" "f2" "f3" | <== current-output | "f1" | | "f2" "f3" T | | "f2" "f3" | | "f1" | | T | +----------------+ \end{verbatim} \end{describe} \subsection{GENTRANPOP} \begin{describe}{Syntax:} {\bf GENTRANPOP} {\it f1,f2,\dots\ ,fn;} \end{describe} \begin{describe}{Arguments:} {\it f1,f2,\dots\ ,fn\/} is a list of one or more {\it f\/}'s, where each {\it f\/} is one of: \begin{center} \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{center} \end{describe} \begin{describe}{Side Effects:} {\bf GENTRANPOP} deletes the top-most occurrence of the single element containing the file name(s) represented by {\it f1,f2,\dots\ ,fn\/} from the output stack. Files whose names have been completely removed from the output stack are closed. The current output file is reset to the (new) element on the top of the output stack. \end{describe} \begin{describe}{Returned Value:} {\bf GENTRANPOP} returns the current output file(s) after this command has been executed. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** FILE NOT OPEN FOR OUTPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \begin{describe}{Examples:} Output stack: \begin{verbatim} +-------------+ | "f4" | <== current-output | "f4" "f2" T | | "f4" | | T | | "f3" | | "f2" "f1" | | T | +-------------+ \end{verbatim} \begin{verbatim} 1: GENTRANPOP NIL; {"f4","f2",T} \end{verbatim} Output stack: \begin{verbatim} +-------------+ | "f4" "f2" T | <== current-output | "f4" | | T | | "f3" | | "f2" "f1" | | T | +-------------+ \end{verbatim} \begin{verbatim} 2: GENTRANPOP NIL; "f4" \end{verbatim} Output stack: \begin{verbatim} +-------------+ | "f4" | <== current-output | T | | "f3" | | "f2" "f1" | | T | +-------------+ \end{verbatim} \begin{verbatim} 3: GENTRANPOP "f2","f1"; "f4" \end{verbatim} Output stack: \begin{verbatim} +-------------+ | "f4" | <== current-output | T | | "f3" | | T | +-------------+ \end{verbatim} \begin{verbatim} 4: GENTRANPOP ALL!*; T \end{verbatim} Output stack: \begin{verbatim} +-------------+ | T | <== current-output +-------------+ \end{verbatim} \end{describe} \section{Temporary Output Redirection} Sections~\ref{translation} and ~\ref{templates} explain how to use the code generation and template processing commands. The syntax for these two commands is: \begin{tabular}{lll} &\multicolumn{2}{l}{{\bf GENTRAN} {\it stmt\/} [{\bf OUT} {\it f1,f2,\dots\ ,fn\/}]{\it ;}}\\ &&and\\ &\multicolumn{2}{l}{{\bf GENTRANIN} {\it f1,f2,\dots\ ,fm\/} [{\bf OUT} {\it f1,f2,\dots\ ,fn\/}]{\it ;}}\\ \end{tabular} The optional parts of these two commands can be used for {\it temporary} output redirection; they can be used when the current output file is to be temporarily reset, for this command only. Thus the following two sequences of commands are equivalent: \begin{verbatim} 10: GENTRANPUSH "f1",T$ 11: GENTRAN ... $ 12: GENTRANPOP NIL$ \end{verbatim} and \begin{verbatim} 10: GENTRAN 10: ... 10: OUT "f1",T$ \end{verbatim} \chapter{MODIFICATION OF THE CODE GENERATION PROCESS} GENTRAN is designed to be flexible enough to be used in a variety of code generation applications. For this reason, several mode switches and variables are provided to enable the user to tailor the code generation process to meet his or her particular needs. \section{Mode Switches} The following GENTRAN mode switches can be turned on and off with the REDUCE {\bf ON} and {\bf OFF} commands. \begin{describe}{PERIOD} \begin{itemize} \item when turned on, causes all integers to be printed out as floating point numbers except: \begin{itemize} \item exponents; \item variable subscripts; \item index values in DO-type loops; \item those which have been declared to be integers. \end{itemize} \item default setting: on \end{itemize} \end{describe} \begin{describe}{GENTRANSEG} \begin{itemize} \item when turned on, checks the print length of expressions and breaks those expressions that are longer than {\bf MAXEXPPRINTLEN!*} down into subexpressions which are assigned to temporary variables. See also section~\ref{segmentation}. \item default setting: on \end{itemize} \end{describe} \begin{describe}{GENDECS} \begin{itemize} \item when turned on, allows type declarations to be generated automatically; otherwise, type information is stored in but not automatically retrieved from the symbol table. See also sections~\ref{explicit:type}, \ref{more:type} and \ref{template:type}. \item default setting: on \end{itemize} \end{describe} \begin{describe}{GENTRANOPT} \begin{itemize} \item when turned on, replaces each block of straightline code by an optimised sequence of assignments. The Code Optimizer takes a sequence of assignments and replaces common subexpressions with temporary variables. It returns the resulting assignment statements with common-subexpression-to-temporary-variable assignment statements preceding them \item default setting: off \end{itemize} \end{describe} \begin{describe}{DOUBLE} \begin{itemize} \item When turned on, causes (where appropriate): \begin{itemize} \item floating point numbers to be printed in double precision format; \item intrinsic functions to be replaced by their double precision counterparts; \item generated type declarations to be of double precision form. \end{itemize} See also section~\ref{precision}. \item default setting: off \end{itemize} \end{describe} \begin{describe}{MAKECALLS} \begin{itemize} \item when turned on, causes GENTRAN to translate functional expressions as subprogram calls. \item default setting: on \end{itemize} \end{describe} \begin{describe}{GETDECS} \begin{itemize} \item when on, causes: \begin{itemize} \item the indices of loops to be declared integer; \item objects without an explicit type declaration to be declared of the type given by the variable {\bf DEFTYPE!*}. \end{itemize} See also section~\ref{implicit:type}. \item default setting: off \end{itemize} \end{describe} \begin{describe}{KEEPDECS} \begin{itemize} \item when on, prevents declarations being removed from the symbol table when type declarations are generated. \item default: off \end{itemize} \end{describe} \section{Variables} Several global variables are provided in GENTRAN to enable the user to \begin{itemize} \item select the target language \item control expression segmentation \item change automatically generated variable names and statement numbers \item modify the code formatter \end{itemize} The following four subsections describe these variables\footnote{ Note that when an atomic value (other than an integer) is assigned to a variable, that value must be quoted. For example, {\bf GENTRANLANG!* := 'FORTRAN\$} assigns the atom {\bf FORTRAN} to the variable {\bf GENTRANLANG!*}.}. \subsection{Target Language Selection} \begin{describe}{GENTRANLANG!*} \begin{itemize} \item target language (FORTRAN, RATFOR, PASCAL or C) See also section~\ref{gentranlang}. \item value type: atom \item default value: FORTRAN \end{itemize} \end{describe} \subsection{Expression Segmentation Control} \begin{describe}{MAXEXPPRINTLEN!*} \begin{itemize} \item value used to determine whether or not an expression should be segmented; maximum number of characters permitted in an expression in the target language (excluding spaces printed for formatting). See also section~\ref{segmentation}. \item value type: integer \item default value: 800 \end{itemize} \end{describe} \subsection{Variable Names \& Statement Numbers} \begin{describe}{TEMPVARNAME!*} \begin{itemize} \item name used as prefix in generating temporary variable names. See also section~\ref{tempvars}. \item value type: atom \item default value: T \end{itemize} \end{describe} \begin{describe}{TEMPVARNUM!*} \begin{itemize} \item number appended to {\bf TEMPVARNAME!*} to create a temporary variable name. If the temporary variable name resulting from appending {\bf TEMPVARNUM!*} onto {\bf TEMPVARNAME!*} has already been generated and still holds a useful value, then {\bf TEMPVARNUM!*} is incremented and temporary variable names are compressed until one is found which was not previously generated or does not still hold a significant value. See also section~\ref{tempvars}. \item value type: integer \item default value: 0 \end{itemize} \end{describe} \begin{describe}{TEMPVARTYPE!*} \begin{itemize} \item target language variable type (e.g., INTEGER, REAL!*8, FLOAT, etc) used as a default for automatically generated variables whose type cannot be determined otherwise. If {\bf TEMPVARTYPE!*} is NIL, then generated temporary variables whose type cannot be determined are not automatically declared. See also section~\ref{tempvars}. \item value type: atom \item default value: NIL \end{itemize} \end{describe} \begin{describe}{GENSTMTNUM!*} \begin{itemize} \item number used when a statement number must be generated \item value type: integer \item default value: 25000 \end{itemize} \end{describe} \begin{describe}{GENSTMTINCR!*} \begin{itemize} \item number by which {\bf GENSTMTNUM!*} is increased each time a new statement number is generated. \item value type: integer \item default value: 1 \end{itemize} \end{describe} \begin{describe}{DEFTYPE!*} \begin{itemize} \item default type for objects when the switch {\bf GETDECS} is on. See also section~\ref{implicit:type}. \item value type: atom \item default value: real \end{itemize} \end{describe} \subsection{Code Formatting} \begin{describe}{FORTCURRIND!*} \begin{itemize} \item number of blank spaces printed at the beginning of each line of generated FORTRAN code beyond column 6 \item value type: integer \item default value: 0 \end{itemize} \end{describe} \begin{describe}{RATCURRIND!*} \begin{itemize} \item number of blank spaces printed at the beginning of each line of generated RATFOR code. \item value type: integer \item default value: 0 \end{itemize} \end{describe} \begin{describe}{CCURRIND!*} \begin{itemize} \item number of blank spaces printed at the beginning of each line of generated C code. \item value type: integer \item default value: 0 \end{itemize} \end{describe} \begin{describe}{PASCCURRIND!*} \begin{itemize} \item number of blank spaces printed at the beginning of each line of generated PASCAL code. \item value type: integer \item default value: 0 \end{itemize} \end{describe} \begin{describe}{TABLEN!*} \begin{itemize} \item number of blank spaces printed for each new level of indentation. \item value type: integer \item default value: 4 \end{itemize} \end{describe} \begin{describe}{FORTLINELEN!*} \begin{itemize} \item maximum number of characters printed on each line of generated FORTRAN code. \item value type: integer \item default value: 72 \end{itemize} \end{describe} \begin{describe}{RATLINELEN!*} \begin{itemize} \item maximum number of characters printed on each line of generated RATFOR code. \item value type: integer \item default value: 80 \end{itemize} \end{describe} \begin{describe}{CLINELEN!*} \begin{itemize} \item maximum number of characters printed on each line of generated C code. \item value type: integer \item default value: 80 \end{itemize} \end{describe} \begin{describe}{PASCLINELEN!*} \begin{itemize} \item maximum number of characters printed on each line of generated PASCAL code. \item value type: integer \item default value: 70 \end{itemize} \end{describe} \begin{describe}{MINFORTLINELEN!*} \begin{itemize} \item minimum number of characters printed on each line of generated FORTRAN code after indentation. \item value type: integer \item default value: 40 \end{itemize} \end{describe} \begin{describe}{MINRATLINELEN!*} \begin{itemize} \item minimum number of characters printed on each line of generated RATFOR code after indentation. \item value type: integer \item default value: 40 \end{itemize} \end{describe} \begin{describe}{MINCLINELEN!*} \begin{itemize} \item minimum number of characters printed on each line of generated C code after indentation. \item value type: integer \item default value: 40 \end{itemize} \end{describe} \begin{describe}{MINPASCLINELEN!*} \begin{itemize} \item minimum number of characters printed on each line of generated PASCAL code after indentation. \item value type: integer \item default value: 40 \end{itemize} \end{describe} \chapter{EXAMPLES} Short examples have been given throughout this manual to illustrate usage of the GENTRAN commands. This section gives complete code generation examples. \section{Example 1: Interactive Code Generation} Suppose we wish to generate a FORTRAN subprogram which can be used for computing the roots of a polynomial by Graeffe's Root-Squaring Method\footnote{ This is for instance convenient for ill-conditioned polynomials. More details are given in {\it Introduction to Numerical Analysis\/} by C. E. Froberg, Addison-Wesley Publishing Company, 1966.}. This method states that the roots $x_i$ of a polynomial $$P_n(x) = \sum_{i=0}^{n}{a_i x^{n-i}} $$ can be found by constructing the polynomial $$P^{*}_n\left({x^2}\right) = \left( a_0x^n + a_2x^{n-2} + \dots\right)^2 - \left( a_1x^{n-1} + a_3x^{n-3} + \dots\right)^2$$ with roots $x_i^2$ When read into REDUCE, the following file of REDUCE statements will place the coefficients of $P^{*}_n$ into the list B for some user-entered value of n greater than zero. Contents of file graeffe.red:\footnote{ In accordance with section~\ref{explicit:type}, the subscripts of A are I+1 instead of I.} \begin{framedverbatim} OPERATOR A$ Q := FOR I := 0 STEP 2 UNTIL n SUM (A(I+1)*X^(n-I))$ R := FOR I := 1 STEP 2 UNTIL n-1 SUM (A(I+1)*X^(n-I))$ P := Q^2 - R^2$ LET X^2 = Y$ B := COEFF(P,Y)$ END$ \end{framedverbatim} Now a numerical subprogram can be generated with assignment statements for the coefficients of $P^{*}_n$ (now stored in list B in REDUCE). Since these coefficients are given in terms of the coefficients of $P_n$ (i.e., operator A in REDUCE), the subprogram will need two parameters: A and B, each of which must be arrays of size n+1. The following REDUCE session will create subroutine GRAEFF for a polynomial of degree n=10 and write it to file graeffe.f: \begin{verbatim} 1: n := 10$ 2: IN "graeffe.red"$ 3: GENTRANLANG!* := 'FORTRAN$ 4: ON DOUBLE$ 5: GENTRAN 5: ( 5: PROCEDURE GRAEFF(A,B); 5: BEGIN 5: DECLARE 5: << 5: GRAEFF : SUBROUTINE; 5: A(11),B(11) : REAL 5: >>; 5: LITERAL 5: "C",CR!*, 5: "C",TAB!*,"GRAEFFE ROOT-SQUARING METHOD TO FIND ROOTS OF A POLYNOMIAL",CR!*, 5: "C",CR!*; 5: B(1) :=: PART (B,1); 5: B(2) :=: PART (B,2); 5: B(3) :=: PART (B,3); 5: B(4) :=: PART (B,4); 5: B(5) :=: PART (B,5); 5: B(6) :=: PART (B,6); 5: B(7) :=: PART (B,7); 5: B(8) :=: PART (B,8); 5: B(9) :=: PART (B,9); 5: B(10) :=: PART (B,10); 5: B(11) :=: PART (B,11) 5: END 5: ) 5: OUT "graeffe.f"$ \end{verbatim} Contents of file graeffe.f: \begin{framedverbatim} SUBROUTINE GRAEFF(A,B) DOUBLE PRECISION A(11),B(11) C C GRAEFFE ROOT-SQUARING METHOD TO FIND ROOTS OF A POLYNOMIAL C B(1)=A(11)**2 B(2)=2.0D0*A(11)*A(9)-A(10)**2 B(3)=2.0D0*A(11)*A(7)-(2.0D0*A(10)*A(8))+A(9)**2 B(4)=2.0D0*A(11)*A(5)-(2.0D0*A(10)*A(6))+2.0D0*A(9)*A(7)-A(8)**2 B(5)=2.0D0*A(11)*A(3)-(2.0D0*A(10)*A(4))+2.0D0*A(9)*A(5)-(2.0D0*A( . 8)*A(6))+A(7)**2 B(6)=2.0D0*A(11)*A(1)-(2.0D0*A(10)*A(2))+2.0D0*A(9)*A(3)-(2.0D0*A( . 8)*A(4))+2.0D0*A(7)*A(5)-A(6)**2 B(7)=2.0D0*A(9)*A(1)-(2.0D0*A(8)*A(2))+2.0D0*A(7)*A(3)-(2.0D0*A(6) . *A(4))+A(5)**2 B(8)=2.0D0*A(7)*A(1)-(2.0D0*A(6)*A(2))+2.0D0*A(5)*A(3)-A(4)**2 B(9)=2.0D0*A(5)*A(1)-(2.0D0*A(4)*A(2))+A(3)**2 B(10)=2.0D0*A(3)*A(1)-A(2)**2 B(11)=A(1)**2 RETURN END \end{framedverbatim} \section{Example 2: Code Generation, Segmentation \& Temporary Variables} The following 3 x 3 inertia matrix M was derived in the course of some research \footnote{For details see: Bos, A. M. and M. J. L. Tiernego. ``Formula Manipulation in the Bond Graph Modelling and Simulation of Large Mechanical Systems'', {\it Journal of the Franklin Institut} , Pergamon Press Ltd., Vol. 319, No. 1/2, pp. 51-65, January/February 1985.}: \begin{eqnarray*} M(1,1) & = & 18*\cos (q_3)*\cos (q_2)*m_{30}*p^2 - \sin ^2(q_3) *j_{30}y + \sin ^2(q_3) *j_{30}z - 9*\sin ^2(q_3) *m_{30}*p^2 +\\ & &j_{10}y + j_{30}y + m_{10}*p^2 + 18*m_{30}*p^2\\ M(1,2) & = & 9*\cos (q_3)*\cos (q_2)*m_{30}*p^2 - \sin ^2(q_3) *j_{30}y +\sin ^2(q_3) *j_{30}z - 9*\sin ^2(q_3) *m_{30}*p^2 \\ & &+ j_{30}y + 9* m_{30}*p^2\\ M(2,1) & = & M(1,2)\\ M(1,3) & = & - 9*\sin (q_3)*\sin (q_2)*m_{30}*p^2\\ M(3,1) & = & M(1,3)\\ M(2,2) & = & - \sin ^2(q_3) *j_{30}y + \sin ^2(q_3) *j_{30}z - 9*\sin ^2(q_3)*m_{30}*p^2 + j_{30}y + 9*m_{30}*p^2\\ M(2,3) & = & 0\\ M(3,2) & = & M(2,3)\\ M(3,3) & = & 9*m_{30}*p^2 + j_{30}x\\ \end{eqnarray*} We know M is symmetric. We wish to generate numerical code to compute values for M and its inverse matrix. \subsection{Code Generation} \label{code:example} Generating code for matrix M and its inverse matrix is straightforward. We can simply generate an assignment statement for each element of M, compute the inverse matrix MIV, and generate an assignment statement for each element of MIV. Since we know M is symmetric, we know that MIV will also be symmetric. To avoid duplicate computations, we will not generate assignments for elements below the main diagonals of these matrices. Instead, we will copy elements across the main diagonal by generating nested loops. The following REDUCE session will write to the file m1.f: \begin{verbatim} 1: IN "m.red"$ % Initialise M 2: GENTRANOUT "m1.f"$ 3: GENTRANLANG!* := 'FORTRAN$ 4: ON DOUBLE$ 5: FOR J := 1 : 3 DO 5: FOR K := J : 3 DO 5: GENTRAN M(J,K) ::=: M(J,K)$ 6: MIV := M^(-1)$ 7: FOR J := 1 : 3 DO 7: FOR K := J : 3 DO 7: GENTRAN MIV(J,K) ::=: MIV(J,K)$ 8: GENTRAN 8: FOR J := 1 : 3 DO 8: FOR K := J+1 : 3 DO 8: << 8: M(K,J) := M(J,K); 8: MIV(K,J) := MIV(J,K) 8: >>$ 9: GENTRANSHUT "m1.f"$ \end{verbatim} The contents of m1.f are reproduced in appendix C. This code was generated with the segmentation facility turned off. However, most FORTRAN compilers cannot handle statements more than 20 lines long. The next section shows how to generate segmented assignments. \subsection{Segmentation} \label{seg:example} Large arithmetic expressions can be broken into pieces of manageable size with the expression segmentation facility. The following REDUCE session will write segmented assignment statements to the file m2.f. Large arithmetic expressions will be broken into subexpressions of approximately 300 characters in length. \begin{verbatim} 1: IN "m.red"$ % Initialise M 2: GENTRANOUT "m2.f"$ 3: ON DOUBLE$ 4: ON GENTRANSEG$ 5: MAXEXPPRINTLEN!* := 300$ 6: FOR J := 1 : 3 DO 6: FOR K := J : 3 DO 6: GENTRAN M(J,K) ::=: M(J,K)$ 7: MIV := M^(-1)$ 8: FOR J := 1 : 3 DO 8: FOR K := J : 3 DO 8: GENTRAN MIV(J,K) ::=: MIV(J,K)$ 9: GENTRAN 9: FOR J := 1 : 3 DO 9: FOR K := J+1 : 3 DO 9: << 9: M(K,J) := M(J,K); 9: MIV(K,J) := MIV(J,K) 9: >>$ 10: GENTRANSHUT "m2.f"$ \end{verbatim} The contents of file m2.f are reproduced in appendix C. \subsection{Generation of Temporary Variables to Suppress Simplification} \label{tempvar:example} We can dramatically improve the efficiency of the code generated in sections~\ref{code:example} and \ref{seg:example} by replacing expressions by temporary variables before computing the inverse matrix. This effectively suppresses simplification; these expressions will not be substituted into later computations. We will replace each non-zero element of the REDUCE matrix M by a generated variable name, and generate a numerical assignment statement to reflect that substitution in the numerical program being generated. The following REDUCE session will write to the file m3.f: \begin{verbatim} 1: in "m.red"$ % Initialise M 2: GENTRANOUT "m3.f"$ 3: GENTRANLANG!* := 'FORTRAN$ 4: ON DOUBLE$ 5: FOR J := 1 : 3 DO 5: FOR K := J : 3 DO 5: GENTRAN M(J,K) ::=: M(J,K)$ 6: SHARE VAR$ 7: FOR J := 1 : 3 DO 7: FOR K := J : 3 DO 7: IF M(J,K) NEQ 0 THEN 7: << 7: VAR := TEMPVAR(NIL)$ 7: MARKVAR VAR$ 7: M(J,K) := VAR$ 7: M(K,J) := VAR$ 7: GENTRAN 7: EVAL(VAR) := M(EVAL(J),EVAL(K)) 7: >>$ 8: COMMENT ** Contents of matrix M: **$ 9: M; [T0 T1 T2] [ ] [T1 T3 0 ] [ ] [T2 0 T4] 10: MIV := M^(-1)$ 11: FOR J := 1 : 3 DO 11: FOR K := J : 3 DO 11: GENTRAN MIV(J,K) ::=: MIV(J,K)$ 12: GENTRAN 12: FOR J := 1 : 3 DO 12: FOR K := J+1 : 3 DO 12: << 12: M(K,J) := M(J,K); 12: MIV(K,J) := MIV(J,K) 12: >>$ 13: GENTRANSHUT "m3.f"$ \end{verbatim} Contents of file m3.f: \begin{framedverbatim} M(1,1)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*Y* . J30)+DSIN(DBLE(Q3))**2*J30Z+18.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))* . P**2*M30+18.0D0*P**2*M30+P**2*M10+J30Y+J10Y M(1,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2 . *M30+9.0D0*P**2*M30+J30Y M(1,3)=-(9.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P**2*M30) M(2,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*P**2*M30+J30Y M(2,3)=0.0D0 M(3,3)=9.0D0*P**2*M30+J30X T0=M(1,1) T1=M(1,2) T2=M(1,3) T3=M(2,2) T4=M(3,3) MIV(1,1)=-(T4*T3)/(T4*T1**2-(T4*T3*T0)+T2**2*T3) MIV(1,2)=(T4*T1)/(T4*T1**2-(T4*T3*T0)+T2**2*T3) MIV(1,3)=(T2*T3)/(T4*T1**2-(T4*T3*T0)+T2**2*T3) MIV(2,2)=(-(T4*T0)+T2**2)/(T4*T1**2-(T4*T3*T0)+T2**2*T3) MIV(2,3)=-(T1*T2)/(T4*T1**2-(T4*T3*T0)+T2**2*T3) MIV(3,3)=(T1**2-(T3*T0))/(T4*T1**2-(T4*T3*T0)+T2**2*T3) DO 25009 J=1,3 DO 25010 K=J+1,3 M(K,J)=M(J,K) MIV(K,J)=MIV(J,K) 25010 CONTINUE 25009 CONTINUE \end{framedverbatim} \section{Example 3: Template Processing} Circuit simulation plays a vital role in computer hardware development. A recent paper\footnote{ Loe, K. F., N. Ohsawa, and E. Goto. ``Design of an Automatic Circuitry Code Generator (ACCG)'', {\it RSYMSAC Proceedings}, Wako-shi, Saitama, Japan. 1984.} describes the design of an Automatic Circuitry Code Generator (ACCG), which generates circuit simulation programs based on user-supplied circuit specifications. The actual code generator consists of a series of REDUCE {\bf WRITE} statements, each of which writes one line of FORTRAN code. This section presents an alternative implementation for the ACCG which uses GENTRAN's template processor to generate code. Template processing is a much more natural method of code generation than the REDUCE {\bf WRITE} statement method. First we will put all REDUCE calculations into two files: rk.red and ham.red. Contents of file rk.red:\footnote{ Line 11 of procedure RUNGEKUTTA was changed from \begin{center} {\tt K41 := HH*SUB(TT=TT+HH, P=P+K31, Q=Q+K32, P2);} \end{center} as given in (Loe84), to \begin{center} {\tt K42 := HH*SUB(TT=TT+HH, P=P+K31, Q=Q+K32, P2);} \end{center} } \begin{framedverbatim} COMMENT -- RUNGE-KUTTA METHOD --$ PROCEDURE RUNGEKUTTA(P1, P2, P, Q, TT); BEGIN SCALAR K11,K12,K21,K22,K31,K32,K41,K42; K11 := HH*P1; K12 := HH*P2; K21 := HH*SUB(TT=TT+HH/2, P=P+K11/2, Q=Q+K12/2, P1); K22 := HH*SUB(TT=TT+HH/2, P=P+K11/2, Q=Q+K12/2, P2); K31 := HH*SUB(TT=TT+HH/2, P=P+K21/2, Q=Q+K22/2, P1); K32 := HH*SUB(TT=TT+HH/2, P=P+K21/2, Q=Q+K22/2, P2); K41 := HH*SUB(TT=TT+HH, P=P+K31, Q=Q+K32, P1); K42 := HH*SUB(TT=TT+HH, P=P+K31, Q=Q+K32, P2); PN := P + (K11 + 2*K21 + 2*K31 + K41)/6; QN := Q + (K12 + 2*K22 + 2*K32 + K42)/6 END$ END$ \end{framedverbatim} Contents of file ham.red: \begin{framedverbatim} COMMENT -- HAMILTONIAN CALCULATION --$ DIFQ := DF(H,P)$ DIFP := -DF(H,Q) - SUB(QDOT=P/M, DF(D,QDOT))$ RUNGEKUTTA(DIFP, DIFQ, P, Q, TT)$ END$ \end{framedverbatim} Next we will create a template file with an outline of the target FORTRAN program and GENTRAN commands. Contents of file runge.tem: \begin{framedverbatim} PROGRAM RUNGE IMPLICIT DOUBLE PRECISION (K,M) C C INPUT C WRITE(6,*) 'INITIAL VALUE OF P' READ(5,*) P WRITE(6,*) ' P = ', P WRITE(6,*) 'INITIAL VALUE OF Q' READ(5,*) Q WRITE(6,*) ' Q = ', Q WRITE(6,*) 'VALUE OF M' READ(5,*) M WRITE(6,*) ' M = ', M WRITE(6,*) 'VALUE OF K0' READ(5,*) K0 WRITE(6,*) ' K0 = ', K0 WRITE(6,*) 'VALUE OF B' READ(5,*) B WRITE(6,*) ' B = ', B WRITE(6,*) 'STEP SIZE OF T' READ(5,*) HH WRITE(6,*) ' STEP SIZE OF T = ', HH WRITE(6,*) 'FINAL VALUE OF T' READ(5,*) TP WRITE(6,*) ' FINAL VALUE OF T = ', TP C C INITIALIZATION C TT=0.0D0 ;BEGIN; GENTRAN LITERAL TAB!*, "WRITE(9,*) ' H = ", EVAL(H), "'", CR!*, TAB!*, "WRITE(9,*) ' D = ", EVAL(D), "'", CR!*$ ;END; WRITE(9,901) C 901 FORMAT(' C= ',D20.10) WRITE(9,910) TT, Q, P 910 FORMAT(' '3D20.10) C C LOOP C ;BEGIN; GENTRAN REPEAT << PN :=: PN; Q :=: QN; P := PN; TT := TT + HH; LITERAL TAB!*, "WRITE(9,910) TT, QQ, P", CR!* >> UNTIL TT >= TF$ ;END; STOP END ;END; \end{framedverbatim} Now we can generate a circuit simulation program simply by starting a REDUCE session and following three steps: \begin{enumerate} \item Enter circuit specifications. \item Perform calculations. \item Call the GENTRAN template processor. \end{enumerate} For example, the following REDUCE session will write a simulation program to the file runge.f: \begin{verbatim} 1: COMMENT -- INPUT --$ 2: K := 1/(2*M)*P^2$ % kinetic energy 3: U := K0/2*Q^2$ % potential energy 4: D := B/2*QDOT$ % dissipating function 5: H := K + U$ % hamiltonian 6: COMMENT -- CALCULATIONS --$ 7: IN "rk.red", "ham.red"$ 8: COMMENT -- FORTRAN CODE GENERATION --$ 9: GENTRANLANG!* := 'FORTRAN$ 10: ON DOUBLE$ 11: GENTRANIN "runge.tem" OUT "runge.f"$ \end{verbatim} Contents of file runge.f: \begin{framedverbatim} PROGRAM RUNGE IMPLICIT DOUBLE PRECISION (K,M) C C INPUT C WRITE(6,*) 'INITIAL VALUE OF P' READ(5,*) P WRITE(6,*) ' P = ', P WRITE(6,*) 'INITIAL VALUE OF Q' READ(5,*) Q WRITE(6,*) ' Q = ', Q WRITE(6,*) 'VALUE OF M' READ(5,*) M WRITE(6,*) ' M = ', M WRITE(6,*) 'VALUE OF K0' READ(5,*) K0 WRITE(6,*) ' K0 = ', K0 WRITE(6,*) 'VALUE OF B' READ(5,*) B WRITE(6,*) ' B = ', B WRITE(6,*) 'STEP SIZE OF T' READ(5,*) HH WRITE(6,*) ' STEP SIZE OF T = ', HH WRITE(6,*) 'FINAL VALUE OF T' READ(5,*) TP WRITE(6,*) ' FINAL VALUE OF T = ', TP C C INITIALIZATION C TT=0.0D0 WRITE(9,*) ' H = (M*Q**2*K0+P**2)/(2.0D0*M)' WRITE(9,*) ' D = (B*QDOT)/2.0D0' WRITE(9,901) C 901 FORMAT(' C= ',D20.10) WRITE(9,910) TT, Q, P 910 FORMAT(' '3D20.10) C C LOOP C 25001 CONTINUE PN=(-(12.0D0*B*M**2*HH)+2.0D0*B*M*K0*HH**3+24.0D0*M**2*P-( . 24.0D0*M**2*Q*K0*HH)-(12.0D0*M*P*K0*HH**2)+4.0D0*M*Q*K0**2*HH . **3+P*K0**2*HH**4)/(24.0D0*M**2) Q=(-(12.0D0*B*M*HH**2)+B*K0*HH**4+48.0D0*M**2*Q+48.0D0*M*P*HH- . (24.0D0*M*Q*K0*HH**2)-(8.0D0*P*K0*HH**3)+2.0D0*Q*K0**2*HH**4) . /(48.0D0*M**2) P=PN TT=TT+HH WRITE(9,910) TT, QQ, P IF (.NOT.TT.GE.TF) GOTO 25001 STOP END \end{framedverbatim} \chapter{SYMBOLIC MODE FUNCTIONS} Thus far in this manual, commands have been presented which are meant to be used primarily in the algebraic mode of REDUCE. These commands are designed to be used interactively. However, many code generation applications require code to be generated under program control. ((van den Heuvel, 1986) contains one such example.) In these applications, it is generally more convenient to generate code from (computed) prefix forms. Therefore, GENTRAN provides code generation and file handling functions designed specifically to be used in the symbolic mode of REDUCE. This section presents the symbolic functions which are analogous to the code generation, template processing, and output file handling commands presented in sections 2, 3, and 4. \section{Code Generation and Translation} Sections~\ref{translation} through \ref{comments} describe interactive commands and functions which generate and translate code, declare variables to be of specific types, and insert literal strings of characters into the stream of generated code. This section describes analogous symbolic mode code generation functions. \subsection{Translation of Prefix Forms} In algebraic mode, the {\bf GENTRAN} command translates algorithmic specifications supplied in the form of REDUCE statements into numerical code. Similarly, the symbolic function {\bf SYM!-GENTRAN} translates algorithmic specifications supplied in the form of REDUCE prefix forms into numerical code. \begin{describe}{Syntax:} {\bf SYM!-GENTRAN} {\it form\/}; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it form\/} is any LISP prefix form that evaluates to a REDUCE prefix form that can be translated by GENTRAN into the target language\footnote{ See Appendix A for a complete listing of REDUCE prefix forms that can be translated.}. {\it form\/} may contain any number of occurrences of the special forms {\bf EVAL}, {\bf LSETQ}, {\bf RSETQ}, {\bf LRSETQ}, {\bf DECLARE}, and {\bf LITERAL} (see sections~\ref{sym:cg} through \ref{special}). \end{describe} \begin{describe}{Side Effects:} {\bf SYM!-GENTRAN} translates {\it form\/} into formatted code in the target language and writes it to the file(s) currently selected for output. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRAN} returns the name(s) of the file(s) to which code was written. If code was written to one file, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** WRONG TYPE OF ARG \end{verbatim} {\it exp} \begin{verbatim} ***** CANNOT BE TRANSLATED \end{verbatim} \end{describe} \begin{describe}{Examples:} \begin{verbatim} 1: SYMBOLIC$ 2: GENTRANLANG!* := 'FORTRAN$ 3: SYM!-GENTRAN '(FOR I (1 1 n) DO (SETQ (V I) 0))$ DO 25001 I=1,N V(I)=0.0 25001 CONTINUE 4: GENTRANLANG!* := 'RATFOR$ 5: SYM!-GENTRAN '(FOR I (1 1 N) DO 5: (FOR J ((PLUS I 1) 1 N) DO 5: (PROGN 5: (SETQ (X J I) (X I J)) 5: (SETQ (Y J I) (Y I J)))))$ DO I=1,N DO J=I+1,N { X(J,I)=X(I,J) Y(J,I)=Y(I,J) } 6: GENTRANLANG!* := 'C$ 7: SYM!-GENTRAN '(SETQ P (FOR I (1 1 N) PRODUCT I))$ { P=1; for (I=1;I<=N;++I) P*=I; } 8: GENTRANLANG!* := 'PASCAL$ 9: SYM!-GENTRAN '(SETQ C 9: (COND ((LESSP A B) A) (T B)))$ IF A<B THEN C:=A; ELSE C:=B; \end{verbatim} \end{describe} \subsection{Code Generation} \label{sym:cg} Sections~\ref{eval} through~\ref{lrsetq} described the special functions and operators {\bf EVAL}, {\bf ::=}, {\bf :=:}, and {\bf ::=:} that could be included in arguments to the {\bf GENTRAN} command to indicate that parts of those arguments were to be given to REDUCE FOR Evaluation prior to translation. This section describes the analogous functions that can be supplied in prefix form to the {\bf SYM!-GENTRAN} function. The following special forms may be interleaved arbitrarily in forms supplied as arguments to {\bf SYM!-GENTRAN} to specify partial evaluation: {\bf EVAL}, {\bf LSETQ}, {\bf RSETQ}, and {\bf LRSETQ}. Sections~\ref{sym:eval} through \ref{sym:lrsetq} describe these forms. Then section~\ref{lispeval} through \ref{share} present examples of the usage of these forms for evaluation of expressions in both symbolic and algebraic modes. \subsubsection{The EVAL Form} \label{sym:eval} \begin{describe}{Syntax:} {\bf (EVAL} {\it form\/}{\bf )} \end{describe} \begin{describe}{Argument:} {\it form\/} is any LISP prefix form that evaluates to a REDUCE prefix form that can be translated by GENTRAN into the target language. \end{describe} \subsubsection{The LSETQ Form} \begin{describe}{Syntax:} {\bf (LSETQ} {\it svar exp\/}{\bf )} \end{describe} \begin{describe}{Arguments:} {\it svar\/} is a subscripted variable in LISP prefix form. Its subscripts must evaluate to REDUCE prefix forms that can be translated into the target language. {\it exp\/} is any REDUCE expression in prefix form that can be translated by GENTRAN. \end{describe} \subsubsection{The RSETQ Form} \begin{describe}{Syntax:} {\bf (RSETQ} {\it var exp\/}{\bf )} \end{describe} \begin{describe}{Arguments:} {\it var\/} is a variable in REDUCE prefix form. {\it exp\/} is a LISP prefix form which evaluates to a translatable REDUCE prefix form. \end{describe} \subsubsection{The LRSETQ Form} \label{sym:lrsetq} \begin{describe}{Syntax:} {\bf (LRSETQ} {\it svar exp\/}{\bf )} \end{describe} \begin{describe}{Arguments:} {\it svar\/} is a subscripted variable in LISP prefix form with subscripts that evaluate to REDUCE prefix forms that can be translated by GENTRAN. {\it exp\/} is a LISP prefix form that evaluates to a translatable REDUCE prefix form. \end{describe} \subsubsection{Symbolic Mode Evaluation} \label{lispeval} The symbolic mode evaluation forms that have just been described are analogous to their algebraic mode counterparts, except that by default, they evaluate their argument(s) in symbolic mode. The following is an example of evaluation of subscripts in symbolic mode: \begin{describe}{Example:} \begin{verbatim} 1: SYMBOLIC$ 2: FOR i:=1:2 DO 2: FOR j:=1:2 DO 2: SYM!-GENTRAN '(LSETQ (M i j) 0)$ M(1,1)=0.0 M(1,2)=0.0 M(2,1)=0.0 M(2,2)=0.0 \end{verbatim} \end{describe} \subsubsection{Algebraic Mode Evaluation} As we have just seen, the symbolic mode evaluation forms evaluate their argument(s) in symbolic mode. This default evaluation mode can be overridden by explicitly requesting evaluation in algebraic mode with the REDUCE {\bf AEVAL} function. \begin{describe}{Examples:} \begin{verbatim} 1: ALGEBRAIC$ 2: F := 2*x^2 - 5*X + 6$ 3: SYMBOLIC$ 4: SYM!-GENTRAN '(SETQ Q (QUOTIENT 4: (EVAL (AEVAL 'F)) 4: (EVAL (AEVAL '(DF F X)))))$ Q=(2.0*X**2-5.0*X+6.0)/(4.0*X-5.0) 5: ALGEBRAIC$ 6: M := MAT(( A, 0, -1, 1), 6: ( 0, B^2, 0, 1), 6: (-1, B, B*C, 0), 6: ( 1, 0, -C, -D))$ 7: SYMBOLIC$ 8: FOR i:=1:4 DO 8: SYM!-GENTRAN '(LRSETQ (M i i) 8: (AEVAL (MKQUOTE (LIST 'M i i))))$ M(1,1)=A M(2,2)=B**2 M(3,3)=B*C M(4,4)=-D \end{verbatim} \end{describe} \subsubsection{SHAREd Variables} \label{share} The REDUCE {\bf SHARE} command (Hearn, 1985) enables variables to be shared between algebraic and symbolic modes. Thus, we can derive an expression in algebraic mode, assign it to a shared variable, and then access the value of that variable to generate code from symbolic mode. \begin{describe}{Example:} \begin{verbatim} 1: ALGEBRAIC$ 2: SHARE dfx1$ 3: dfx1 := DF(X**4 - X**3 + 2*X**2 + 1, X)$ 4: SYMBOLIC$ 5: SYM!-GENTRAN '(RSETQ DERIV dfx1)$ DERIV=4.0*X**3-(3.0*X**2)+4.0*X \end{verbatim} \end{describe} \subsection{Special Translatable Forms} \label{special} Sections~\ref{explicit:type} through \ref{comments} described special functions that could be used to declare variable types and insert literal strings of characters into generated code. This section contains explanations of analogous prefix forms for usage in symbolic mode. \subsubsection{Explicit Type Declarations} A similar form of the algebraic mode {\bf DECLARE} function is provided in symbolic mode: \begin{describe}{Syntax:} \begin{tabular}{ll} {\bf (DECLARE} & {\bf (}{\it type1 v1 v2 \dots\ vn1\/}{\bf )}\\ & {\bf (}{\it type2 v1 v2 \dots\ vn2\/}{\bf )}\\ & \ \ \ :\\ & {\bf (}{\it typen v1 v2 \dots\ vnn\/}{\bf )) }\\ \end{tabular} \end{describe} \begin{describe}{Arguments:} Each {\it v1 v2 \dots\ vn\/} is a sequence of one or more variables (optionally subscripted to indicate array dimensions -- in prefix form), or variable ranges (two letters concatenated together with "-" in between). {\it v\/}s are not evaluated unless given as arguments to {\bf EVAL}. Each {\it type\/} is a variable type in the target language. Each must be an atom, optionally concatenated to the atom {\bf IMPLICIT!\ } (note the trailing space). {\it type\/}s are not evaluated unless given as arguments to {\bf EVAL}. \end{describe} \begin{describe}{Side Effect:} Entries are placed in the symbol table for each variable or variable range declared in the call to this function. The function call itself is removed from the statement group being translated. Then after translation, type declarations are generated from these symbol table entries before the resulting executable statements are printed. \end{describe} \begin{describe}{Examples:} \begin{verbatim} 1: SYMBOLIC$ 2: GENTRANLANG!* := 'FORTRAN$ 3: SYM!-GENTRAN 3: '(PROGN 3: (DECLARE (IMPLICIT! REAL!*8 A!-H O!-Z) 3: (INTEGER (M 4 4))) 3: (FOR I (1 1 4) DO 3: (FOR J (1 1 4) DO 3: (COND ((EQUAL I J) (SETQ (M I J) 1)) 3: (T (SETQ (M I J) 0))))) 3: (DECLARE (INTEGER I J)) : : 3: )$ IMPLICIT REAL*8 (A-H,O-Z) INTEGER M(4,4),I,J DO 25001 I=1,4 DO 25002 J=1,4 IF (I.EQ.J) THEN M(I,J)=1 ELSE M(I,J)=0 ENDIF 25002 CONTINUE 25001 CONTINUE : : 4: GENTRANLANG!* := 'RATFOR$ 5: SYM!-GENTRAN 5: '(PROCEDURE FAC NIL EXPR (N) 5: (BLOCK () 5: (DECLARE (FUNCTION FAC) 5: (INTEGER FAC N)) 5: (SETQ F (FOR I (1 1 N) PRODUCT I)) 5: (DECLARE (INTEGER F I)) 5: (RETURN F)))$ INTEGER FUNCTION FAC(N) INTEGER N,F,I { F=1 DO I=1,N F=F*I } RETURN(F) END 6: GENTRANLANG!* := 'C$ 7: SYM!-GENTRAN 7: '(PROCEDURE FAC NIL EXPR (N) 7: (BLOCK () 7: (DECLARE (INTEGER FAC N I F)) 7: (SETQ F (FOR I (1 1 N) PRODUCT I)) 7: (RETURN F)))$ int FAC(N) int N; { int I,F; { F=1; for (I=1;I<=N;++I) F*=I; } return(F); } 8: GENTRANLANG!* := 'PASCAL$ 9: SYM!-GENTRAN 9: '(PROCEDURE FAC NIL EXPR (N) 9: (BLOCK () 9: (DECLARE (INTEGER FAC N I F)) 9: (SETQ F (FOR I (1 1 N) PRODUCT I)) 9: (RETURN F)))$ FUNCTION FAC(N:INTEGER):INTEGER; LABEL 99999; VAR I,F: INTEGER; BEGIN BEGIN F:=1; FOR I:=1 TO N DO F:=F*I END; BEGIN FAC:=F; GOTO 99999{RETURN} END; 99999: END; \end{verbatim} \end{describe} \subsubsection{Comments and Literal Strings} A form similar to the algebraic mode {\bf LITERAL} function is provided in symbolic mode: \begin{describe}{Syntax:} {\bf (LITERAL} {\it arg1 arg2 \dots\ argn\/}{\bf )} \end{describe} \begin{describe}{Arguments:} {\it arg1 arg2 \dots\ argn\/} is an argument sequence containing one or more {\it arg\/}s, where each {\it arg\/} either is, or evaluates to, an atom. The atoms {\bf TAB!*} and {\bf CR!*} have special meanings. {\it arg\/}s are not evaluated unless given as arguments to {\bf EVAL}. \end{describe} \begin{describe}{Side Effect:} This form is replaced by the character sequence resulting from concatenation of the given atoms. Double quotes are stripped from all string type {\it arg\/}s, and the reserved atoms {\bf TAB!*} and {\bf CR!*} are replaced by a tab to the current level of indentation, and an end-of-line character, respectively. \end{describe} \begin{describe}{Examples:} \begin{verbatim} 1: SYMBOLIC$ 2: GENTRANLANG!* := 'FORTRAN$ 3: N := 100$ 4: SYM!-GENTRAN 4: '(PROGN 4: (LITERAL C TAB!* "--THIS IS A FORTRAN COMMENT--" CR!* C CR!*) 4: (LITERAL TAB!* "DATA N/" (EVAL N) "/" CR!*))$ C --THIS IS A FORTRAN COMMENT-- C DATA N/100/ 5: GENTRANLANG!* := 'RATFOR$ 6: SYM!-GENTRAN 6: '(FOR I (1 1 N) DO 6: (PROGN 6: (LITERAL TAB!* "# THIS IS A RATFOR COMMENT" CR!*) 6: (LITERAL TAB!* "WRITE(6,10) (M(I,J),J=1,N)" CR!* 6: 10 TAB!* "FORMAT(1X,10(I5,3X))" CR!*)))$ DO I=1,N { # THIS IS A RATFOR COMMENT WRITE(6,10) (M(I,J),J=1,N) 10 FORMAT(1X,10(I5,3X)) } 7: GENTRANLANG!* := 'C$ 8: SYM!-GENTRAN 8: '(PROGN 8: (SETQ X 0) 8: (LITERAL "/* THIS IS A" CR!* " C COMMENT */" CR!*))$ { X=0.0; /* THIS IS A C COMMENT */ } 9: GENTRANLANG!* := 'PASCAL$ 10: SYM!-GENTRAN 10: '(PROGN 10: (SETQ X (SIN Y)) 10: (LITERAL "{ THIS IS A PASCAL COMMENT }" CR!*))$ BEGIN X:=SIN(Y) { THIS IS A PASCAL COMMENT } END; \end{verbatim} \end{describe} \section{Template Processing} The template processor can be invoked from either algebraic or symbolic mode. Section~\ref{templates} described the algebraic mode command. This section describes the analogous symbolic mode function. \begin{describe}{Syntax:} {\bf SYM!-GENTRANIN} {\it list-of-fnames\/}; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it list-of-fnames\/} evaluates to a LISP list containing one or more {\it fname\/}s, where each {\it fname\/} is one of: \begin{tabular}{lll} {\it an atom} & = & a template (input) file\\ {\bf T} & = & the terminal\\ \end{tabular} \end{describe} \begin{describe}{Side Effects:} {\bf SYM!-GENTRANIN} processes each template file in {\it list-of-fnames\/} sequentially. A template file may contain any number of parts, each of which is either an active or an inactive part. All active parts start with the character sequence {\bf ;BEGIN;} and end with {\bf ;END;}. The end of the template file is indicated by an extra {\bf ;END;} character sequence. Inactive parts of template files are assumed to contain code in the target language (FORTRAN, RATFOR, PASCAL or C, depending on the value of the global varibale {\bf GENTRANLANG!*}). All inactive parts are copied to the output. Comments delimited by the appropriate characters are also copied in their entirety to the output. Thus the character sequences {\bf ;BEGIN;} and {\bf ;END;} have no special meanings within comments. Active parts may contain any number of REDUCE expressions, statements, and commands. They are not copied directly to the output. Instead, they are given to REDUCE for evaluation in algebraic mode\footnote{ Active parts are evaluated in algebraic mode unless the mode is explicitly changed to symbolic from within the active part itself. This is true regardless of which mode the system was in when the template processor was called.}. All output generated by each evaluation is sent to the file(s) currently selected for output. Returned values are only printed on the terminal. Active parts will most likely contain calls to GENTRAN to generate code. This means that the result of processing a template file will be the original template file with all active parts replaced by generated code. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRANIN} returns the name(s) of the file(s) to which code was written. If code was written to one file, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** NONEXISTENT INPUT FILE ***** TEMPLATE FILE ALREADY OPEN FOR INPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \section{Output Redirection} Section 4 describes four slgebraic mode commands which select, open, and close output files. The algebraic mode {\bf GENTRANOUT}, {\bf GENTRANSHUT}, {\bf GENTRANPUSH}, and {\bf GENTRANPOP} commands are analogous to the symbolic mode {\bf SYM!-GENTRANOUT}, {\bf SYM!-GENTRANSHUT}, {\bf SYM!-GENTRANPUSH}, and {\bf SYM!-GENTRANPOP} functions, respectively. \subsection{SYM!-GENTRANOUT} \begin{describe}{Syntax:} {\bf SYM!-GENTRANOUT} {\it list-of-fnames\/}; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it list-of-fnames\/} evaluates to a LISP list containing one or more {\it fname\/}s, where each {\it fname} is one of: \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{describe} \begin{describe}{Side Effect:} GENTRAN maintains a list of files currently open for output by GENTRAN {\it only}. {\bf SYM!-GENTRANOUT} inserts each file name represented in {\it list-of-fnames\/} into that list and opens each one for output. It also resets the currently selected output file(s) to be all of the files represented in {\it list-of-fnames}. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRANOUT} returns the name(s) of the file(s) represented by {\it list-of-fnames\/}; i.e., the current output file(s) after the command has been executed. If there is only one file selected for output, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \subsection{SYM!-GENTRANSHUT} \begin{describe}{Syntax:} {\bf SYM!-GENTRANSHUT} {\it list-of-fnames\/} ; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it list-of-fnames\/} evaluates to a LISP list containing one or more {\it fnames}, where each {\it fname\/} is one of: \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{describe} \begin{describe}{Side Effects:} {\bf SYM!-GENTRANSHUT} creates a list of file names from {\it list-of-fnames}, deletes each from the output file list, and closes the corresponding files. If (all of) the current output file(s) are closed, then the current output file is reset to the terminal. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRANSHUT} returns the name(s) of the file(s) selected for output after the command has been executed. If there is only one file selected for output, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** FILE NOT OPEN FOR OUTPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \subsection{SYM!-GENTRANPUSH} \begin{describe}{Syntax:} {\bf SYM!-GENTRANPUSH} {\it list-of-fnames\/}; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it list-of-fnames\/} evaluates to a LISP list containing one or more {\it fname}s, each of which is one of: \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{describe} \begin{describe}{Side Effects:} {\bf SYM!-GENTRANPUSH} creates a list of file name(s) from {\it lis-of-fnames\/} and pushes that list onto the output stack. Each file in the list that is not already open for output is opened at this time. The current output file is reset to this new element on the top of the stack. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRANPUSH} returns the name(s) of the file(s) represented by {\it list-of-fnames\/}; i.e., the current output file(s) after the command has been executed. If there is only one file selected for output, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** OUTPUT FILE ALREADY EXISTS OVERWRITE FILE? (Y/N) ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \subsection{SYM!-GENTRANPOP} \begin{describe}{Syntax:} {\bf SYM!-GENTRANPOP} {\it list-of-fnames\/}; \end{describe} \begin{describe}{Function Type:} expr \end{describe} \begin{describe}{Argument:} {\it list-of-fnames\/} evaluates to a LISP list containing one or more {\it fname\/}s, where each {\it fname\/} is one of: \begin{tabular}{lll} {\it an atom} & = & an output file\\ {\bf T} & = & the terminal\\ {\bf NIL} & = & the current output file(s)\\ {\bf ALL!*} & = & all files currently open for output by GENTRAN\\ \end{tabular} \end{describe} \begin{describe}{Side Effects:} {\bf SYM!-GENTRANPOP} deletes the top-most occurrence of the single element containing the file name(s) represented by {\it list-of-fnames\/} from the output stack. Files whose names have been completely removed from the output stack are closed. The current output file is reset to the (new) element on the top of the output stack. \end{describe} \begin{describe}{Returned Value:} {\bf SYM!-GENTRANPOP} returns the name(s) of the file(s) selected for output after the command has been executed. If there is only one file selected for output, the returned value is an atom; otherwise, it is a list. \end{describe} \begin{describe}{Diagnostic Messages:} \begin{verbatim} *** FILE NOT OPEN FOR OUTPUT ***** WRONG TYPE OF ARG \end{verbatim} \end{describe} \chapter{REFERENCES} American National Standards Institute. ``American National Standard Programming Language FORTRAN'', ANS X3.9, New York. 1978. Gates, Barbara L. ``GENTRAN: An Automatic Code Generation Facility for REDUCE'', \it ACM SIGSAM Bulletin \rm , Vol. 19, No. 3. August 1985. Gates, Barbara L. ``GENTRAN Design and Implementation - REDUCE Version'', Memorandum INF-85-12, Twente University of Technology, Department of Computer Science, Enschede, The Netherlands. 1985. Gates, Barbara L. ``A Numerical Code Generation Facility for REDUCE'', \it Proceedings of SYMSAC '86 \rm , University of Waterloo, Waterloo, Ontario, Canada. July 21-23, 1986. Gates, Barbara L. and Paul S. Wang. ``A LISP-Based RATFOR Code Generator'', \it Proceedings of the 1984 MACSYMA User's Conference \rm , Schenectady, New York. July 1984. Hearn, Anthony C. (ed.) \it REDUCE User's Manual \rm , Version 3.2, The Rand Corporation, Santa Monica, California. April 1985. Kernighan, Brian W. ``RATFOR -- A Preprocessor for a Rational Fortran'', \it UNIX Programmer's Manual \rm , Vol. 2B, Seventh Edition, Bell Telephone Laboratories, Inc., Murray Hill, New Jersey. 1979. Kernighan, Brian W. and Dennis M. Ritchie. \it The C Programming Language \rm , Prentice-Hall, Englewood Cliffs, New Jersey. 1978. Utah Symbolic Computation Group. \it The Portable Standard LISP User's Manual \rm , Version 3.2, University of Utah, Department of Computer Science, Salt Lake City, Utah. March 1984. van den Heuvel, Pim. ``Aspects of Program Generation Related to Automatic Differentiation'', Master's Thesis, Twente University of Technology, Department of Computer Science, Enschede, The Netherlands. December 1986. van Hulzen, J.A.,B. J. A. Hulshof, B. L. Gates and M. C. van Heerwaarden ``A Code Optimization Package for REDUCE'' \it Proceedings of ISSAC 1989 \rm , ACM 1989. \it NGI-SION Symposium Proceedings \rm , Amsterdam, The Netherlands. 1984. Wang, Paul S. ``FINGER: A Symbolic System for Automatic Generation of Numerical Programs in Finite Element Analysis'', \it Journal of Symbolic Computation \rm , 2, Academic Press Inc. (London) Ltd. 1986. Wang, Paul S., T. Y. P. Chang, and J. A. van Hulzen. ``Code Generation and Optimization for Finite Element Analysis'', \it EUROSAM '84 Conference Proceedings \rm , Springer-Verlag LNCS Series. 1984. \appendix \chapter{TRANSLATABLE REDUCE EXPRESSIONS \& STATEMENTS} A substantial subset of all REDUCE expressions and statements can be translated by GENTRAN into semantically equivalent code in the target numerical language\footnote{ It should be noted that call-by-value parameter passing is used in REDUCE, whereas call-by-address parameter passing is normally used in FORTRAN and RATFOR. GENTRAN does {\it not} attempt to simulate call-by-value passing in FORTRAN and RATFOR, although this could be done by generating temporary variables, assigning values to them, and using them in subprogram calls.}. This appendix contains examples and a formal definition of translatable REDUCE expressions and statements. \section{ Examples of Translatable Statements} The following three tables contain listings of REDUCE statement types that can be translated by GENTRAN. An example of each statement type is shown, and FORTRAN, RATFOR, PASCAL and C code generated for each example is also shown. \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf FORTRAN CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Assignments: & &\\ & & \\ simple &{\bf V:=X\^{}2+X\$} &\verb! V=X**2+X!\\ & & \\ matrix &{\bf M:=MAT((U,V),(W,X))\$} &\verb! M(1,1)=U!\\ & &\verb! M(1,2)=V!\\ & &\verb! M(2,1)=W!\\ & &\verb! M(2,2)=X!\\ & & \\ sum &{\bf S:=FOR I:=1:10} &\verb! S=0.0!\\ &{\bf\ \ \ \ \ \ SUM V(I)\$} &\verb! DO 25001 I=1,10!\\ & &\verb! S=S+V(I)!\\ & &\verb!25001 CONTINUE!\\ & & \\ product &{\bf P:=FOR I:=2 STEP 2} &\verb! P=1!\\ &{\bf\ \ \ \ \ \ \ \ UNTIL N} &\verb! DO 25002 I=2,N,2!\\ &{\bf \ \ \ \ PRODUCT I\$} &\verb! P=P*I!\\ & &\verb!25002 CONTINUE!\\ & & \\ conditional & {\bf X := IF A$<$B THEN} &\verb! IF (A.LT.B) THEN!\\ & {\bf \ \ \ \ \ \ \ \ A ELSE B\$} &\verb! X=A!\\ & &\verb! ELSE!\\ & &\verb! X=B!\\ & &\verb! ENDIF!\\ & & \\ \hline Control & & \\ Structures: & &\\ & & \\ Loops: & &\\ & &\\ for &{\bf FOR I:=1:8 DO} &\verb! DO 25003 I=1,8!\\ &{\bf \ \ \ \ V(I):=0.0\$} &\verb! V(I)=0.0!\\ & &\verb!25003 CONTINUE!\\ & & \\ while &{\bf WHILE F(N)$>$0.0 DO} &\verb!25004 IF(.NOT.F(N).GT.0.0)GOTO 25005!\\ &{\bf \ \ \ \ N:=N+1\$} &\verb! N=N+1!\\ & &\verb! GOTO 25004!\\ & &\verb!25005 CONTINUE!\\ & & \\ repeat &{\bf REPEAT X:=X/2.0} &\verb!25006 CONTINUE!\\ &{\bf \ \ \ \ UNTIL F(X)$<$0.0\$} &\verb! X=X/2.0!\\ & &\verb! IF(.NOT.F(X).LT.0.0)GOTO 25006!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf FORTRAN CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Conditionals:& &\\ & &\\ if &{\bf IF X$>$0.0 THEN Y:=X\$} &\verb! IF (X.GT.0.0) THEN!\\ & &\verb! Y=X!\\ & &\verb! ENDIF!\\ & &\\ if - else &{\bf IF X$>$0.0 THEN Y:=X} &\verb! IF (X.GT.0.0) THEN!\\ &{\bf\ \ \ \ ELSE Y:=-X\$}&\verb! Y=X!\\ & &\verb! ELSE!\\ & &\verb! Y=-X!\\ & &\verb! ENDIF!\\ & & \\\hline Unconditional& &\\ Transfer of & &\\ Control: & &\\ & &\\ goto&{\bf GOTO LOOP\$} &\verb! GOTO 25010!\\ & &\\ call&{\bf CALCV(V,X,Y,Z)\$} &\verb! CALL CALCV(V,X,Y,Z)!\\ & &\\ return &{\bf RETURN X\^{}2\$} &\verb! !{\it functionname\/}\verb!=X**2!\\ & &\verb! RETURN!\\ & & \\\hline Sequences \& & &\\ Groups: & &\\ & &\\ sequence &{\bf $<$$<$ U:=X\^{}2;V:=Y\^{}2$>$$>$\$}&\verb! U=X**2!\\ & &\verb! V=Y**2!\\ & &\\ group &{\bf BEGIN}&\verb! U=X**2!\\ &{\bf\ \ \ \ U:=X\^{}2;}&\verb! V=Y**2!\\ &{\bf\ \ \ \ V:=Y\^{}2} &\\ &{\bf END\$}&\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf RATFOR CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Assignments: & &\\ & & \\ simple &{\bf V:=X\^{}2+X\$} &\verb!V=X**2+X!\\ & & \\ matrix &{\bf M:=MAT((U,V),(W,X))\$} &\verb!M(1,1)=U!\\ & &\verb!M(1,2)=V!\\ & &\verb!M(2,1)=W!\\ & &\verb!M(2,2)=X!\\ & & \\ sum &{\bf S:=FOR I:=1:10} &\verb!S=0.0!\\ &{\bf\ \ \ \ \ \ SUM V(I)\$} &\verb!DO I=1,10!\\ & &\verb! S=S+V(I)!\\ & & \\ product &{\bf P:=FOR I:=2 STEP 2} &\verb!P=1!\\ &{\bf\ \ \ \ \ \ \ \ UNTIL N} &\verb!DO I=2,N,2!\\ &{\ \ \ \ PRODUCT I\$} &\verb! P=P*I!\\ & & \\ conditional & {\bf X := IF A$<$B THEN} &\verb!IF (A<B)!\\ & {\bf \ \ \ \ \ \ \ \ A ELSE B\$} &\verb! X=A!\\ & &\verb!ELSE!\\ & &\verb! X=B!\\ & & \\\hline Control & & \\ Structures: & &\\ & & \\ Loops: & &\\ & &\\ for &{\bf FOR I:=1:8 DO} &\verb!DO I=1,8!\\ &{\bf \ \ \ \ V(I):=0.0\$} &\verb! V(I)=0.0!\\ & & \\ while &{\bf WHILE F(N)$>$0.0 DO} &\verb!WHILE(F(N)>0.0)!\\ &{\bf \ \ \ \ N:=N+1\$} &\verb! N=N+1!\\ & & \\ repeat &{\bf REPEAT X:=X/2.0} &\verb!REPEAT!\\ &{\bf \ \ \ \ UNTIL F(X)$<$0.0\$} &\verb! X=X/2.0!\\ & &\verb!UNTIL(F(X)<0.0)!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf RATFOR CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Conditionals:& &\\ & &\\ if &{\bf IF X$>$0.0 THEN Y:=X\$} &\verb!IF(X>0.0)!\\ & &\verb! Y=X!\\ & &\\ if - else &{\bf IF X$>$0.0 THEN Y:=X} &\verb!IF(X>0.0)!\\ &{\bf\ \ \ \ ELSE Y:=-X\$}&\verb! Y=X!\\ & &\verb!ELSE!\\ & &\verb! Y=-X!\\ & & \\\hline Unconditional& &\\ Transfer of & &\\ Control: & &\\ & &\\ goto&{\bf GOTO LOOP\$} &\verb!GOTO 25010!\\ & &\\ call&{\bf CALCV(V,X,Y,Z)\$} &\verb!CALL CALCV(V,X,Y,Z)!\\ & &\\ return &{\bf RETURN X\^{}2\$} &\verb!RETURN(X**2)!\\ & & \\\hline Sequences \& & &\\ Groups: & &\\ & &\\ sequence &{\bf $<$$<$ U:=X\^{}2;V:=Y\^{}2$>$$>$\$}&\verb!U=X**2!\\ & &\verb!V=Y**2!\\ & &\\ group &{\bf BEGIN}&\verb!{!\\ &{\bf\ \ \ \ U:=X\^{}2;}& \verb! U=X**2!\\ &{\bf\ \ \ \ V:=Y\^{}2} & \verb! V=Y**2!\\ &{\bf END\$}&\verb!}!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf PASCAL CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Assignments: & &\\ & & \\ simple &{\bf V:=X\^{}2+X\$} &\verb!V=X**2+X;!\\ & & \\ matrix &{\bf M:=MAT((U,V),(W,X))\$} &\verb!BEGIN!\\ & &\verb! M(1,1)=U;!\\ & &\verb! M(1,2)=V;!\\ & &\verb! M(2,1)=W;!\\ & &\verb! M(2,2)=X;!\\ & &\verb!END;!\\ & & \\ sum &{\bf S:=FOR I:=1:10} &\verb!BEGIN!\\ &{\bf\ \ \ \ \ \ SUM V(I)\$} &\verb! S=0.0!\\ & &\verb! FOR I:=1 TO 10 DO!\\ & &\verb! S:=S+V(I)!\\ & &\verb!END;!\\ & & \\ product &{\bf P:=FOR I:=2:N} &\verb!BEGIN!\\ &{\bf \ \ \ \ PRODUCT I\$} &\verb! P:=1;!\\ & &\verb! FOR I:=2 TO N DO!\\ & &\verb! P:=P*I!\\ & &\verb!END;!\\ & & \\ conditional & {\bf X := IF A$<$B THEN} &\verb!IF (A<B) THEN!\\ & \ \ \ \ \ \ {\bf \ \ \ \ \ \ \ \ A ELSE B\$} &\verb! X:=A;!\\ & &\verb!ELSE!\\ & &\verb! X:=B;!\\ & & \\ \hline Control & & \\ Structures: & &\\ & & \\ Loops: & &\\ & &\\ for &{\bf FOR I:=1:8 DO} &\verb!FOR I:=1 TO 8 DO!\\ &{\bf \ \ \ \ V(I):=0.0\$} &\verb! V(I):=0.0;!\\ & & \\ while &{\bf WHILE F(N)$>$0.0 DO} &\verb!WHILE (F(N)>0.0)!\\ &{\bf \ \ \ \ N:=N+1\$} &\verb! N:=N+1.0;!\\ & & \\ repeat &{\bf REPEAT X:=X/2.0} &\verb!REPEAT!\\ &{\bf \ \ \ \ UNTIL F(X)$<$0.0\$} &\verb! X:=X/2.0!\\ & &\verb!UNTIL F(X)<0.0;!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf PASCAL CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Conditionals:& &\\ & &\\ if &{\bf IF X$>$0.0 THEN Y:=X\$} &\verb!IF X>0.0 THEN!\\ & &\verb! Y:=X;!\\ & &\\ if - else &{\bf IF X$>$0.0 THEN Y:=X} &\verb!IF X>0.0 THEN!\\ &{\bf\ \ \ \ ELSE Y:=-X\$}&\verb! Y:=X;!\\ & &\verb!ELSE!\\ & &\verb! Y:=-X;!\\ & & \\\hline Unconditional& &\\ Transfer of & &\\ Control: & &\\ & &\\ goto&{\bf GOTO LOOP\$} &\verb!GOTO 25010;!\\ & &\\ call&{\bf CALCV(V,X,Y,Z)\$} &\verb!CALCV(V,X,Y,Z);!\\ & &\\ return &{\bf RETURN X\^{}2\$} &{\it functionname\/}\verb!=X**2;!\\ & &\verb!GOTO 99999{RETURN}!\\ & &\verb!99999;!\\ & & \\\hline Sequences \& & &\\ Groups: & &\\ & &\\ sequence &{\bf $<$$<$ U:=X\^{}2;V:=Y\^{}2$>$$>$\$}&\verb!BEGIN!\\ &&\verb! U:=X**2;!\\ &&\verb! V:=Y**2!\\ &&\verb!END;!\\ & &\\ group &{\bf BEGIN}&\verb!BEGIN!\\ &{\bf\ \ \ \ U:=X\^{}2;}&\verb! U:=X**2;!\\ &{\bf\ \ \ \ V:=Y\^{}2} &\verb! V:=Y**2!\\ &{\bf END\$}&\verb!END!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf C CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Assignments: & &\\ & & \\ simple &{\bf V:=X\^{}2+X\$} &\verb!V=power(X,2)+X;!\\ & & \\ matrix &{\bf M:=MAT((U,V),(W,X))\$} &\verb!M[1][1]=U;!\\ & &\verb!M[1][2]=V;!\\ & &\verb!M[2][1]=W;!\\ & &\verb!M[2][2]=X;!\\ & & \\ sum &{\bf S:=FOR I:=1:10} &\verb!S=0.0;!\\ &{\bf\ \ \ \ \ \ SUM V(I)\$} &\verb!for(I=1;I<=10;++I)!\\ & &\verb! S+=V[I];!\\ & & \\ product &{\bf P:=FOR I:=2 STEP 2} &\verb!P=1;!\\ &{\bf\ \ \ \ \ \ \ \ UNTIL N} &\verb!for(I=2;I<=N;++I)!\\ &{\ \ \ \ PRODUCT I\$} &\verb! P*=I;!\\ & & \\ conditional & {\bf X := IF A$<$B THEN} &\verb!if (A<B)!\\ & {\bf \ \ \ \ \ \ \ \ A ELSE B\$} &\verb! X=A;!\\ & &\verb!else!\\ & &\verb! X=B;!\\ & & \\\hline Control & & \\ Structures: & &\\ & & \\ Loops: & &\\ & &\\ for &{\bf FOR I:=1:8 DO} &\verb!for(I=1;I<=8;++I)!\\ &{\bf \ \ \ \ V(I):=0.0\$} &\verb! V[I]=0.0;!\\ & & \\ while &{\bf WHILE F(N)$>$0.0 DO} &\verb!while(F(N)>0.0)!\\ &{\bf \ \ \ \ N:=N+1\$} &\verb! N+=1;!\\ & & \\ repeat &{\bf REPEAT X:=X/2.0} &\verb!do!\\ &{\bf \ \ \ \ UNTIL F(X)$<$0.0\$} &\verb! X/=2.0;!\\ & &\verb!while(F(X)>=0.0);!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \begin{figure} \begin{center} \begin{tabular}{||l|l|l||}\hline\hline {\bf STATEMENT} & {\bf EXAMPLE} & {\bf C CODE} \\ {\bf \ \ \ TYPE} & & \\ \hline\hline Conditionals:& &\\ & &\\ if &{\bf IF X$>$0.0 THEN Y:=X\$} &\verb!if(X>0.0)!\\ & &\verb! Y=X;!\\ & &\\ if - else &{\bf IF X$>$0.0 THEN Y:=X} &\verb!if(X>0.0)!\\ &{\bf\ \ \ \ ELSE Y:=-X\$}&\verb! Y=X;!\\ & &\verb!else!\\ & &\verb! Y=-X;!\\ & & \\\hline Unconditional& &\\ Transfer of & &\\ Control: & &\\ & &\\ goto&{\bf GOTO LOOP\$} &\verb!goto LOOP;!\\ & &\\ call&{\bf CALCV(V,X,Y,Z)\$} &\verb!CALCV(V,X,Y,Z);!\\ & &\\ return &{\bf RETURN X\^{}2\$} &\verb!return(power(X,2) );!\\ & & \\\hline Sequences \& & &\\ Groups: & &\\ & &\\ sequence &{\bf $<$$<$ U:=X\^{}2;V:=Y\^{}2$>$$>$\$}&\verb!U=power(X,2);!\\ & &\verb!V=power(Y,2);!\\ & &\\ group &{\bf BEGIN}&\verb!{!\\ &{\bf\ \ \ \ U:=X\^{}2;}& \verb! U=power(x,2);!\\ &{\bf\ \ \ \ V:=Y\^{}2} & \verb! V=power(Y,2);!\\ &{\bf END\$}&\verb!}!\\ & & \\\hline\hline \end{tabular} \end{center} \end{figure} \section{Formal Definition} The remainder of this appendix contains a formal definition of all REDUCE expressions, statements, and prefix forms that can be translated by GENTRAN into FORTRAN, RATFOR, PASCAL and C code. \begin{describe}{Preliminary Definitions} An {\it id\/} is an identifier. Certain {\it id\/}'s are reserved words and may not be used as array names or subprogram names. The complete list appears in the {\it Reserved Words\/} section. A {\it string\/} consists of any number of characters (excluding double quotes) which are enclosed in double quotes. \end{describe} \begin{describe}{Reserved Words} The following reserved words may not be used as array names or subprogram names\footnote{Note that names of other built-in REDUCE functions {\it can\/} be translated, but remember that they will be translated {\it literally\/} unless {\bf EVAL}'d first. For example: {\bf GENTRAN~DERIV~:=~DF(2*X\^{}2-X-1,~X)\$} generates {\tt DERIV=DF(2*X**2-X-1,X)} whereas {\bf GENTRAN~DERIV~:=:~DF(2*X\^{}2-X-1,~X)\$} generates {\tt DERIV=4*X-1} }: {\bf AND, BLOCK, COND, DIFFERENCE, EQUAL, EXPT, FOR, GEQ, GO, GREATERP, LEQ, LESSP, MAT, MINUS, NEQ, NOT, OR, PLUS, PROCEDURE, PROGN, QUOTIENT, RECIP, REPEAT, RETURN, SETQ, TIMES, WHILE, WRITE} \end{describe} \subsection{Translatable REDUCE Expressions and Statements} \begin{describe}{Expressions} \begin{tabular}{lll} \multicolumn{3}{l}{Arithmetic Expressions:} \\ & & \\ exp & ::= & {\it number} $\mid$ var $\mid$ funcall $\mid$ - exp $\mid$ / exp $\mid$ exp + exp $\mid$ exp - exp $\mid$ \\ & & exp * exp $\mid$ exp / exp $\mid$ exp ** exp $\mid$ exp \^{} exp $\mid$ ( exp )\\ & & \\ var & ::= & {\it id} $\mid$ {\it id} ( exp$_1$, exp$_2$, \dots\ , exp$_n$ ) $n > 0$ \\ & & \\ funcall & ::= & {\it id} ( arg$_1$, arg$_2$, \dots\ , arg$_n$ ) $n \geq 0$ \\ & & \\ arg & ::= & exp $\mid$ logexp $\mid$ {\it string} \\ & &\\ \multicolumn{3}{l}{Logical Expressions:}\\ & & \\ logexp & ::= & {\it T} $\mid$ {\it NIL} $\mid$ var $\mid$ funcall $\mid$ exp $>$ exp $\mid$ exp $>$= exp $\mid$ exp = exp $\mid$ \\ & & exp {\it NEQ} exp $\mid$ exp $<$ exp $\mid$ exp $<$= exp $\mid$ {\it NOT\/} logexp $\mid$ \\ & & logexp {\it AND\/} logexp $\mid$ logexp {\it OR\/} logexp $\mid$ ( logexp )\\ \end{tabular} \end{describe} \begin{describe}{Operator Precedence} The following is a list of REDUCE arithmetic and logical operators in order of decreasing precedence: \begin{center} ** (or \^{}) / * --- + $<$ $<$= $>$ $>$= NEQ = NOT AND OR \end{center} When unparenthesised expressions are translated which contain operators whose precedence in REDUCE differs from that in the target language, parentheses are automatically generated. Thus the meaning of the original expression is preserved\footnote{ For example in REDUCE, {\bf NOT~A~=~B} and {\bf NOT~(A~=~B)} are equivalent, whereas in C, {\bf !~A~==~B} and {\bf (!A)~==~B} are equivalent. Therefore, {\bf NOT~A~=~B} is translated into C code which forces the REDUCE precedence rules: {\bf !(A~==~B)} }. \end{describe} \begin{describe}{Statements} \begin{tabular}{lll} stmt & ::= & assign $\mid$ break $\mid$ cond $\mid$ while $\mid$ repeat $\mid$ for $\mid$ goto $\mid$ label $\mid$ \\ & & call $\mid$ return $\mid$ stop $\mid$ stmtgp \\ \end{tabular} Assignment Statements: \begin{tabular}{llll} assign & ::= & \multicolumn{2}{l}{var := assign' $\mid$ matassign $\mid$ cond}\\ & & & \\ assign' & ::= & \multicolumn{2}{l}{exp $\mid$ logexp}\\ & & & \\ matassign & ::= & {\it id} := {\it MAT\/} ( &( exp$_{11}$, exp$_{12}$, \dots\ , exp$_{1m}$),\\ & & &( exp$_{21}$, exp$_{22}$, \dots\ , exp$_{2m}$ ),\\ & & & \ \ \ \ \ \ :\\ & & & \ \ \ \ \ \ :\\ & & &( exp$_{n1}$, exp$_{n2}$, \dots\ , exp$_{nm}$ ) ) $n,m > 0$ \\ \end{tabular} Break Statement: break ::= {\it BREAK()} Conditional Statements: \begin{tabular}{lll} cond & ::= & {\it IF\/} logexp {\it THEN\/} stmt\\ & & {\it IF\/} logexp {\it THEN\/} stmt {\it ELSE\/} stmt\\ \end{tabular} Loops: \begin{tabular}{lll} while & ::= & {\it WHILE\/} logexp {\it DO\/} stmt\\ & &\\ repeat & ::= & {\it REPEAT\/} stmt {\it UNTIL\/} logexp\\ & &\\ for & ::= & {\it FOR\/} var := exp {\it STEP\/} exp {\it UNTIL\/} exp {\it DO\/} stmt $\mid$\\ & &{\it FOR\/} var := exp {\it UNTIL\/} exp {\it DO\/} stmt $\mid$\\ & &{\it FOR\/} var := exp : exp {\it DO\/} stmt $\mid$\\ & &var := for' $\mid$ \\ & &\\ for' & ::= & var := for' $\mid$\\ & &{\it FOR\/} var := exp {\it STEP\/} exp {\it UNTIL\/} exp {\it SUM\/} exp $\mid$\\ & &{\it FOR\/} var := exp {\it UNTIL\/} exp {\it SUM\/} exp $\mid$\\ & &{\it FOR\/} var := exp : exp {\it SUM\/} exp $\mid$\\ & &{\it FOR\/} var := exp {\it STEP\/} exp {\it UNTIL\/} exp {\it PRODUCT\/} exp $\mid$\\ & &{\it FOR\/} var := exp {\it UNTIL\/} exp {\it PRODUCT\/} exp $\mid$\\ & &{\it FOR\/} var := exp : exp {\it PRODUCT\/} exp\\ \end{tabular} Goto Statement: \begin{tabular}{lll} goto & ::= & {\it GOTO\/} label $\mid$ {\it GO TO\/} label\\ label & ::= & {\it id\/} :\\ \end{tabular} Subprogram Calls \& Returns \footnote{ Note that return statements can only be translated from inside of procedure definitions. The LITERAL function must be used to generate a return statement from anywhere else.}: \begin{tabular}{lll} call & ::= & {\it id\/} ( arg$_1$, arg$_2$, \dots\ , arg$_n$ ) $n \geq 0$\\ & &\\ return & ::= & {\it RETURN\/} $\mid$ {\it RETURN\/} arg\\ \end{tabular} Stop \& Exit Statements \footnote{ In certain cases it may be convenient to generate a FORTRAN STOP statement or a C EXIT statement. Since there is no semantically equivalent REDUCE statement, STOP() can be used and will be translated appropriately.}: stop ::= {\it STOP\/}() Statement Groups \footnote{ Note that REDUCE BEGIN\dots\ END statement groups are translated into RATFOR or C \{\dots\ \} statement groups, whereas REDUCE $<$$<$\dots\ $>$$>$ statement groups are translated into RATFOR or C statement {\it sequences}. When the target language is FORTRAN, both types of REDUCE statement groups are translated into statement sequences.}: \begin{tabular}{lll} stmtgp & ::= & $<$$<$ stmt$_1$ ; stmt$_2$ ; \dots\ ; stmt$_n$ $>$$>$ $\mid$\\ & &{\it BEGIN\/} stmt$_1$ ; stmt$_2$ ; \dots\ ; stmt$_n$ {\it END\/} $ n > 0$\\ \end{tabular} \end{describe} \begin{describe}{Subprogram Definitions} \begin{tabular}{lll} defn & ::= & {\it PROCEDURE id\/} ({\it id$_1$, id$_2$, \dots\ , id$_n$\/}) ; stmt $\mid$\\ & & {\it PROCEDURE id\/} ({\it id$_1$, id$_2$, \dots\ , id$_n$\/}) ; exp\ \ \ \ \ \ $n \geq 0$ \\ \end{tabular} \end{describe} \subsection{Translatable REDUCE Prefix Forms} \begin{describe}{Expressions} Arithmetic Expressions: \begin{tabular}{lll} exp & ::= & {\it number\/} $\mid$ funcall $\mid$ var $\mid$ ({\it DIFFERENCE\/} exp exp) $\mid$\\ & &({\it EXPT\/} exp exp) $\mid$ ({\it MINUS\/} exp) $\mid$ ({\it PLUS\/} exp exp') $\mid$\\ & & ({\it QUOTIENT\/} exp exp) $\mid$ ({\it RECIP\/} exp) $\mid$\\ & & ({\it TIMES\/} exp exp exp') $\mid$ ({\it !*SQ\/} sqform)\\ \end{tabular} where sqform is a standard quotient form equivalent to any acceptable prefix form. exp' ::= exp$_1$ exp$_2$ \dots\ exp$_n$ $n \geq 0$ Logical Expressions: \begin{tabular}{lll} logexp & ::= & {\it NIL\/} $\mid$ {\it T\/} $\mid$ funcall $\mid$ var $\mid$\\ & & ({\it AND\/} logexp logexp logexp') $\mid$ ({\it EQUAL\/} exp exp) $\mid$\\ & & ({\it GEQ\/} exp exp) $\mid$ ({\it GREATERP\/} exp exp) $\mid$ ({\it LEQ\/} exp exp) $\mid$\\ & & ({\it LESSP\/} exp exp) $\mid$ ({\it NEQ\/} exp exp) $\mid$ ({\it NOT\/} logexp) $\mid$\\ & & ({\it OR\/} logexp logexp logexp')\\ & &\\ logexp' & ::= & logexp$_1$ logexp$_2$ \dots\ logexp$_n$ $n \geq 0$\\ \end{tabular} \end{describe} \begin{describe}{Statements} \begin{tabular}{lll} stmt & ::= & assign $\mid$ break $\mid$ call $\mid$ cond $\mid$ for $\mid$ goto $\mid$\\ & & label $\mid$ read $\mid$ repeat $\mid$ return $\mid$ stmtgp $\mid$\\ & & stop $\mid$ while $\mid$ write \\ & &\\ stmt' & ::= & stmt$_1$ stmt$_2$ \dots\ stmt$_n$ $n \geq 0$\\ \end{tabular} Assignment Statements: assign ::= ({\it SETQ\/} var exp) $\mid$ ({\it SETQ\/} var logexp) $\mid$ ({\it SETQ\/} id ({\it MAT\/} list list')) Conditional Statements: \begin{tabular}{lll} cond & ::= & ({\it COND\/} (logexp stmt) cond1)\\ & & \\ cond1 & ::= & (logexp stmt$_1$) (logexp stmt$_2$) \dots\ (logexp stmt$_n$) $n \geq 0$\\ \end{tabular} Loops: \begin{tabular}{lll} for & ::= & ({\it FOR\/} var (exp exp exp) {\it DO\/} stmt) $\mid$\\ & & ({\it SETQ\/} var ({\it FOR\/} var (exp exp exp) {\it SUM\/} exp) $\mid$\\ & & ({\it SETQ\/} var ({\it FOR\/} var (exp exp exp) {\it PRODUCT\/} exp)\\ & &\\ repeat & ::= & ({\it REPEAT\/} stmt logexp)\\ & &\\ while & ::= & ({\it WHILE\/} logexp stmt) \end{tabular} Go To Statements: \begin{tabular}{lll} break & ::= & ({\it BREAK\/})\\ & & \\ goto & ::= & ({\it GO\/} label)\\ & & \\ label & ::= & {\it id}\\ \end{tabular} Subprogram Calls \& Returns: \begin{tabular}{lll} call & ::= & ({\it id\/} arg')\\ & &\\ return & ::= & ({\it RETURN\/}) $\mid$ ({\it RETURN\/} arg)\\ \end{tabular} Stop \& Exit Statements: stop ::= ({\it STOP\/}) Statement Groups: stmtgp ::= ({\it PROGN\/} stmt stmt') $\mid$ ({\it BLOCK\/} (id') stmt') I/O Statements: \begin{tabular}{lll} read & ::= & ({\it SETQ\/} var ({\it READ\/}))\\ & &\\ write & ::= & ({\it WRITE\/} arg arg')\\ \end{tabular} Subprogram Definitions: defn ::= ({\it PROCEDURE id NIL EXPR\/} (id') stmt) \end{describe} \begin{describe}{Miscellaneous} \begin{tabular}{lll} funcall & ::= & ({\it id\/} arg')\\ & &\\ var & ::= & {\it id\/} $\mid$ ({\it id\/} exp exp')\\ & &\\ arg & ::= & {\it string\/} $\mid$ exp $\mid$ logexp\\ & &\\ arg' & ::= & arg$_1$ arg$_2$ \dots\ arg$_n$ $n \geq 0$ \\ & &\\ list & ::= & (exp exp')\\ & &\\ list' & ::= & list$_1$ list$_2$ \dots\ list$_n$ $n \geq 0$ \\ & &\\ id' & ::= & {\it id$_1$ id$_2$} \dots\ {\it id$_n$} $n \geq 0$ \\ \end{tabular} \end{describe} \chapter{LIST OF COMMANDS, SWITCHES, \& VARIABLES} \begin{describe}{COMMANDS} {\bf GENTRAN} {\it stmt\/} [{\bf OUT}{\it f1,f2,\dots\ ,fn\/}]{\it ;} {\bf GENTRANIN} {\it f1,f2,\dots\ ,fm\/} [{\bf OUT}{\it f1,f2,\dots\ ,fn\/}]{\it ;} {\bf GENTRANOUT} {\it f1,f2,\dots\ ,fn;} {\bf GENTRANSHUT} {\it f1,f2,\dots\ ,fn;} {\bf GENTRANPUSH} {\it f1,f2,\dots\ ,fn;} {\bf GENTRANPOP} {\it f1,f2,\dots\ ,fn;} \end{describe} \begin{describe}{SPECIAL FUNCTIONS \& OPERATORS} {\bf EVAL} {\it exp} {\it var} {\bf ::=} {\it exp;} {\it var} {\bf :=:} {\it exp;} {\it var} {\bf ::=:} {\it exp;} {\it var} {\bf LSETQ} {\it exp;} {\it var} {\bf RSETQ} {\it exp;} {\it var} {\bf LRSETQ} {\it exp;} {\bf DECLARE} {\it v1,v2,\dots\ ,vn\/}{\bf :} {\it type;} \begin{tabular}{ll} {\bf DECLARE}\\ {\bf $<$$<$}\\ &{\it v11,v12,\dots\ ,v1n} {\bf :} {\it type1\/}{\bf ;}\\ &{\it v12,v22,\dots\ ,v2n} {\bf :} {\it type2\/}{\bf ;}\\ & \ \ \ :\\ & \ \ \ :\\ &{\it vm1,vm2,\dots\ ,vmn} {\bf :} {\it typen\/}{\bf ;}\\ {\bf $>$$>$}{\it ;} \end{tabular} {\bf LITERAL} {\it arg1,arg2,\dots\ ,argn;} \end{describe} \begin{describe}{MODE SWITCHES} {\bf PERIOD} {\bf GENTRANSEG} {\bf GENDECS} {\bf DOUBLE} {\bf MAKECALLS} {\bf KEEPDECS} {\bf GETDECS} \end{describe} \begin{describe}{VARIABLES} {\bf GENTRANLANG!*} {\bf MAXEXPPRINTLEN!*} {\bf TEMPVARNAME!*} {\bf TEMPVARNUM!*} {\bf TEMPVARTYPE!*} {\bf GENSTMTNUM!*} {\bf GENSTMTINCR!*} {\bf TABLEN!*} {\bf FORTLINELEN!*} {\bf RATLINELEN!*} {\bf CLINELEN!*} {\bf PASCLINELEN!*} {\bf MINFORTLINELEN!*} {\bf MINRATLINELEN!*} {\bf MINCLINELEN!*} {\bf MINPASCLINELEN!*} {\bf DEFTYPE!*} \end{describe} \begin{describe}{TEMPORARY VARIABLE GENERATION, MARKING \& UNMARKING} {\bf TEMPVAR} {\it type;} {\bf MARKVAR} {\it var;} {\bf UNMARKVAR} {\it var;} \end{describe} \begin{describe}{EXPLICIT GENERATION OF TYPE DECLARATIONS} {\bf GENDECS} {\it subprogname;} \end{describe} \begin{describe}{SYMBOLIC MODE FUNCTIONS} {\bf SYM!-GENTRAN} {\it form;} {\bf SYM!-GENTRANIN} {\it list-of-fnames;} {\bf SYM!-GENTRANOUT} {\it list-of-fnames;} {\bf SYM!-GENTRANSHUT} {\it list-of-fnames;} {\bf SYM!-GENTRANPUSH} {\it list-of-fnames;} {\bf SYM!-GENTRANPOP} {\it list-of-fnames;} \end{describe} \begin{describe}{SYMBOLIC MODE SPECIAL FORMS} \begin{tabular}{ll} {\bf (DECLARE} & {\bf (}{\it type1 v11 v12 \dots\ v1n\/}{\bf )}\\ & {\bf (}{\it type2 v21 v22 \dots\ v2n\/}{\bf )}\\ & \ \ \ :\\ & \ \ \ :\\ & {\bf (}{\it typen vn1 vn2 \dots\ vnn\/}{\bf ))}\\ \end{tabular} {\bf (LITERAL} {\it arg1 arg2 \dots\ argn\/}{\bf )} {\bf (EVAL} {\it exp\/}{\bf )} {\bf (LSETQ} {\it var exp\/}{\bf )} {\bf (RSETQ} {\it var exp\/}{\bf )} {\bf (LRSETQ} {\it var exp\/}{\bf )} \end{describe} \chapter{THE PROGRAMS M1.F AND M2.F.} This appendix contains the two files generated in chapter 6. Contents of file m1.f: \begin{framedverbatim} M(1,1)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*Y* . J30)+DSIN(DBLE(Q3))**2*J30Z+18.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))* . P**2*M30+18.0D0*P**2*M30+P**2*M10+J30Y+J10Y M(1,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2 . *M30+9.0D0*P**2*M30+J30Y M(1,3)=-(9.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P**2*M30) M(2,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*P**2*M30+J30Y M(2,3)=0.0D0 M(3,3)=9.0D0*P**2*M30+J30X MIV(1,1)=(-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE . (Q3))**2*P**2*M30*J30Y)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z-( . 9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30X)-(DSIN(DBLE(Q3))**2*J30Y* . J30X)+DSIN(DBLE(Q3))**2*J30Z*J30X+81.0D0*P**4*M30**2+9.0D0*P**2* . M30*J30Y+9.0D0*P**2*M30*J30X+J30Y*J30X)/(729.0D0*DSIN(DBLE(Q3))** . 4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0*DSIN(DBLE(Q3))**4*DSIN( . DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE . (Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2 . *J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE( . Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30* . J30Z*J30)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30* . J30Y*J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE( . Q3))**4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN . (DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0* . DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0* . DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30 . **2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2* . Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J30Z*J10Y+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2* . J30Y*M10*J30X)+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3 . ))**2*Y*J30Y*J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE( . Q3))**2*J30Y*J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0 . *DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS( . DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30 . **3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4* . M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0 . *P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y* . J30X+9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) MIV(1,2)=(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2+9.0D0*DSIN(DBLE(Q3) . )**2*P**2*M30*J30Y-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30X+DSIN(DBLE(Q3))**2*J30Y*J30X-(DSIN . (DBLE(Q3))**2*J30Z*J30X)-(81.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P . **4*M30**2)-(9.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2*M30*J30X)-( . 81.0D0*P**4*M30**2)-(9.0D0*P**2*M30*J30Y)-(9.0D0*P**2*M30*J30X)-( . J30Y*J30X))/(729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30 . **3+81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-( . 81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+ . 81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3)) . **4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30 . -(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Z*J30)+9.0D0*DSIN(DBLE(Q3 . ))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y . **2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30Z-(9.0D0*DSIN(DBLE( . Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3))**4*Y*J30Y*J30X*J30-( . DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN(DBLE(Q3))**4*J30Y**2* . J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-(729.0D0*DSIN(DBLE(Q3))**2 . *DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*DSIN( . DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0*DSIN(DBLE(Q3))**2*P**6* . M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30**2*M10)-(81.0D0*DSIN( . DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J10Y)-(81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN( . DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y* . M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2 . *M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X)+DSIN(DBLE . (Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y*J30X*J30)+ . DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y*J10Y*J30X) . +DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3))**2*DCOS . (DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2 . ))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2* . M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4* . M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0 . *P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y*J30X+9.0D0*P**2*M30*J10Y* . J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) MIV(1,3)=(-(81.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**4*M30**2)-( . 9.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Y)+9.0D0*DSIN( . DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Z+81.0D0*DSIN(DBLE(Q3))* . DSIN(DBLE(Q2))*P**4*M30**2+9.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P . **2*M30*J30Y)/(729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6* . M30**3+81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2* . J30Y-(81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z . )+81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3 . ))**4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y* . J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Z*J30)+9.0D0*DSIN(DBLE . (Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30* . J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30Z-(9.0D0*DSIN( . DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3))**4*Y*J30Y*J30X* . J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN(DBLE(Q3))**4*J30Y** . 2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-(729.0D0*DSIN(DBLE(Q3)) . **2*DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*DSIN . (DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0*DSIN(DBLE(Q3))**2*P**6* . M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30**2*M10)-(81.0D0*DSIN( . DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J10Y)-(81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN( . DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y* . M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2 . *M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X)+DSIN(DBLE . (Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y*J30X*J30)+ . DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y*J10Y*J30X) . +DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3))**2*DCOS . (DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2 . ))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2* . M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4* . M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0 . *P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y*J30X+9.0D0*P**2*M30*J10Y* . J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) MIV(2,2)=(-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2 . )-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE(Q3))**2 . *P**2*Y*M30*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z-(9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30X)-(DSIN(DBLE(Q3))**2*Y*J30X*J30)+ . DSIN(DBLE(Q3))**2*J30Z*J30X+162.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2)) . *P**4*M30**2+18.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2*M30*J30X+ . 162.0D0*P**4*M30**2+9.0D0*P**4*M30*M10+9.0D0*P**2*M30*J30Y+9.0D0* . P**2*M30*J10Y+18.0D0*P**2*M30*J30X+P**2*M10*J30X+J30Y*J30X+J10Y* . J30X)/(729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+ . 81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-( . 81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+ . 81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3)) . **4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30 . -(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Z*J30)+9.0D0*DSIN(DBLE(Q3 . ))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y . **2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30Z-(9.0D0*DSIN(DBLE( . Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3))**4*Y*J30Y*J30X*J30-( . DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN(DBLE(Q3))**4*J30Y**2* . J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-(729.0D0*DSIN(DBLE(Q3))**2 . *DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*DSIN( . DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0*DSIN(DBLE(Q3))**2*P**6* . M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30**2*M10)-(81.0D0*DSIN( . DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J10Y)-(81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN( . DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y* . M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2 . *M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X)+DSIN(DBLE . (Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y*J30X*J30)+ . DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y*J10Y*J30X) . +DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3))**2*DCOS . (DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2 . ))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2* . M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4* . M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0 . *P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y*J30X+9.0D0*P**2*M30*J10Y* . J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) MIV(2,3)=(81.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**4*M30**2+ . 9.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Y-(9.0D0*DSIN( . DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Z)-(81.0D0*DSIN(DBLE(Q3)) . *DSIN(DBLE(Q2))*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**4*M30**2)-( . 81.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P**4*M30**2)-(9.0D0*DSIN( . DBLE(Q3))*DSIN(DBLE(Q2))*P**2*M30*J30Y))/(729.0D0*DSIN(DBLE(Q3)) . **4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0*DSIN(DBLE(Q3))**4*DSIN( . DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE . (Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2 . *J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE( . Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30* . J30Z*J30)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30* . J30Y*J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE( . Q3))**4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN . (DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0* . DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0* . DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30 . **2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2* . Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J30Z*J10Y+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2* . J30Y*M10*J30X)+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3 . ))**2*Y*J30Y*J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE( . Q3))**2*J30Y*J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0 . *DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS( . DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30 . **3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4* . M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0 . *P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y* . J30X+9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) MIV(3,3)=(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30-(9.0D0*DSIN(DBLE( . Q3))**4*P**2*M30*J30Y)+DSIN(DBLE(Q3))**4*Y*J30Y*J30-(DSIN(DBLE(Q3 . ))**4*Y*J30Z*J30)-(DSIN(DBLE(Q3))**4*J30Y**2)+DSIN(DBLE(Q3))**4* . J30Y*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE . (Q3))**2*P**4*M30*M10)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30)+ . 9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z-(9.0D0*DSIN(DBLE(Q3))**2*P . **2*M30*J10Y)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10)+DSIN(DBLE(Q3))**2 . *P**2*J30Z*M10-(DSIN(DBLE(Q3))**2*Y*J30Y*J30)+DSIN(DBLE(Q3))**2* . J30Y**2-(DSIN(DBLE(Q3))**2*J30Y*J10Y)+DSIN(DBLE(Q3))**2*J30Z*J10Y . -(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2)+81.0D0* . P**4*M30**2+9.0D0*P**4*M30*M10+9.0D0*P**2*M30*J30Y+9.0D0*P**2*M30 . *J10Y+P**2*J30Y*M10+J30Y*J10Y)/(729.0D0*DSIN(DBLE(Q3))**4*DSIN( . DBLE(Q2))**2*P**6*M30**3+81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2)) . **2*P**4*M30**2*J30Y-(81.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2* . P**4*M30**2*J30Z)+81.0D0*DSIN(DBLE(Q3))**4*P**4*Y*M30**2*J30-( . 81.0D0*DSIN(DBLE(Q3))**4*P**4*M30**2*J30Y)+9.0D0*DSIN(DBLE(Q3))** . 4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Z* . J30)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3)-(81.0D0* . DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y)-(729.0D0* . DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3))**2*P**6*M30 . **2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30)+81.0D0*DSIN . (DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . **2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE(Q3))**2*P**4*M30 . *J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10*J30X)-(9.0D0*DSIN . (DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN(DBLE(Q3))**2*P**2* . Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y**2-(9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0*DSIN(DBLE(Q3))**2*P** . 2*M30*J30Z*J10Y+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0 . *DSIN(DBLE(Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2* . J30Y*M10*J30X)+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3 . ))**2*Y*J30Y*J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE( . Q3))**2*J30Y*J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0 . *DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**6*M30**3)-(81.0D0*DCOS( . DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X)+729.0D0*P**6*M30 . **3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2*J30Y+81.0D0*P**4* . M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4*M30*J30Y*M10+9.0D0 . *P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+9.0D0*P**2*M30*J30Y* . J30X+9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) DO 25005 J=1,3 DO 25006 K=J+1,3 M(K,J)=M(J,K) MIV(K,J)=MIV(J,K) 25006 CONTINUE 25005 CONTINUE \end{framedverbatim} \newpage Contents of file m2.f: \begin{framedverbatim} M(1,1)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*Y* . J30)+DSIN(DBLE(Q3))**2*J30Z+18.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))* . P**2*M30+18.0D0*P**2*M30+P**2*M10+J30Y+J10Y M(1,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2 . *M30+9.0D0*P**2*M30+J30Y M(1,3)=-(9.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P**2*M30) M(2,2)=-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30)-(DSIN(DBLE(Q3))**2*J30Y . )+DSIN(DBLE(Q3))**2*J30Z+9.0D0*P**2*M30+J30Y M(2,3)=0.0D0 M(3,3)=9.0D0*P**2*M30+J30X T1=-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE(Q3))** . 2*P**2*M30*J30Y)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z-(9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30X)-(DSIN(DBLE(Q3))**2*J30Y*J30X)+ . DSIN(DBLE(Q3))**2*J30Z*J30X+81.0D0*P**4*M30**2+9.0D0*P**2*M30* . J30Y+9.0D0*P**2*M30*J30X+J30Y*J30X T0=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T0=T0+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T0=T0-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T0=T0+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(1,1)=T1/(T0+9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y* . J10Y*J30X) T0=81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2+9.0D0*DSIN(DBLE(Q3))**2*P . **2*M30*J30Y-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z)+9.0D0*DSIN( . DBLE(Q3))**2*P**2*M30*J30X+DSIN(DBLE(Q3))**2*J30Y*J30X-(DSIN(DBLE . (Q3))**2*J30Z*J30X)-(81.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**4* . M30**2)-(9.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2*M30*J30X)-( . 81.0D0*P**4*M30**2)-(9.0D0*P**2*M30*J30Y) T1=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T1=T1+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T1=T1-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T1=T1+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(1,2)=(T0-(9.0D0*P**2*M30*J30X)-(J30Y*J30X))/(T1+9.0D0*P**2*M30 . *J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) T0=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T0=T0+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T0=T0-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T0=T0+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(1,3)=(-(81.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**4*M30**2)-( . 9.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Y)+9.0D0*DSIN( . DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Z+81.0D0*DSIN(DBLE(Q3))* . DSIN(DBLE(Q2))*P**4*M30**2+9.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P . **2*M30*J30Y)/(T0+9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+ . J30Y*J10Y*J30X) T0=-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2)-( . 81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE(Q3))**2*P . **2*Y*M30*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*M30*J30X)-(DSIN(DBLE(Q3))**2*Y*J30X*J30)+DSIN( . DBLE(Q3))**2*J30Z*J30X+162.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**4 . *M30**2+18.0D0*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**2*M30*J30X+ . 162.0D0*P**4*M30**2 T1=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T1=T1+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T1=T1-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T1=T1+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(2,2)=(T0+9.0D0*P**4*M30*M10+9.0D0*P**2*M30*J30Y+9.0D0*P**2*M30 . *J10Y+18.0D0*P**2*M30*J30X+P**2*M10*J30X+J30Y*J30X+J10Y*J30X)/(T1 . +9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) T0=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T0=T0+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T0=T0-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T0=T0+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T0=T0-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(2,3)=(81.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**4*M30**2+ . 9.0D0*DSIN(DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Y-(9.0D0*DSIN( . DBLE(Q3))**3*DSIN(DBLE(Q2))*P**2*M30*J30Z)-(81.0D0*DSIN(DBLE(Q3)) . *DSIN(DBLE(Q2))*DCOS(DBLE(Q3))*DCOS(DBLE(Q2))*P**4*M30**2)-( . 81.0D0*DSIN(DBLE(Q3))*DSIN(DBLE(Q2))*P**4*M30**2)-(9.0D0*DSIN( . DBLE(Q3))*DSIN(DBLE(Q2))*P**2*M30*J30Y))/(T0+9.0D0*P**2*M30*J10Y* . J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) T0=9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30-(9.0D0*DSIN(DBLE(Q3))**4 . *P**2*M30*J30Y)+DSIN(DBLE(Q3))**4*Y*J30Y*J30-(DSIN(DBLE(Q3))**4*Y . *J30Z*J30)-(DSIN(DBLE(Q3))**4*J30Y**2)+DSIN(DBLE(Q3))**4*J30Y* . J30Z-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2)-(9.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30*M10)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z T0=T0-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J10Y)-(DSIN(DBLE(Q3))**2*P . **2*J30Y*M10)+DSIN(DBLE(Q3))**2*P**2*J30Z*M10-(DSIN(DBLE(Q3))**2* . Y*J30Y*J30)+DSIN(DBLE(Q3))**2*J30Y**2-(DSIN(DBLE(Q3))**2*J30Y* . J10Y)+DSIN(DBLE(Q3))**2*J30Z*J10Y-(81.0D0*DCOS(DBLE(Q3))**2*DCOS( . DBLE(Q2))**2*P**4*M30**2)+81.0D0*P**4*M30**2+9.0D0*P**4*M30*M10+ . 9.0D0*P**2*M30*J30Y T1=729.0D0*DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**6*M30**3+81.0D0* . DSIN(DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y-(81.0D0*DSIN . (DBLE(Q3))**4*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Z)+81.0D0*DSIN( . DBLE(Q3))**4*P**4*Y*M30**2*J30-(81.0D0*DSIN(DBLE(Q3))**4*P**4*M30 . **2*J30Y)+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30Y*J30-(9.0D0*DSIN . (DBLE(Q3))**4*P**2*Y*M30*J30Z*J30) T1=T1+9.0D0*DSIN(DBLE(Q3))**4*P**2*Y*M30*J30X*J30-(9.0D0*DSIN(DBLE . (Q3))**4*P**2*M30*J30Y**2)+9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y* . J30Z-(9.0D0*DSIN(DBLE(Q3))**4*P**2*M30*J30Y*J30X)+DSIN(DBLE(Q3)) . **4*Y*J30Y*J30X*J30-(DSIN(DBLE(Q3))**4*Y*J30Z*J30X*J30)-(DSIN( . DBLE(Q3))**4*J30Y**2*J30X)+DSIN(DBLE(Q3))**4*J30Y*J30Z*J30X-( . 729.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DSIN(DBLE(Q3))**2*DSIN(DBLE(Q2))**2*P**4*M30**2*J30Y . )-(729.0D0*DSIN(DBLE(Q3))**2*P**6*M30**3)-(81.0D0*DSIN(DBLE(Q3)) . **2*P**6*M30**2*M10)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*Y*M30**2*J30) . +81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30Z-(81.0D0*DSIN(DBLE(Q3)) . **2*P**4*M30**2*J10Y)-(81.0D0*DSIN(DBLE(Q3))**2*P**4*M30**2*J30X) T1=T1-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*J30Y*M10)+9.0D0*DSIN(DBLE( . Q3))**2*P**4*M30*J30Z*M10-(9.0D0*DSIN(DBLE(Q3))**2*P**4*M30*M10* . J30X)-(9.0D0*DSIN(DBLE(Q3))**2*P**2*Y*M30*J30Y*J30)-(9.0D0*DSIN( . DBLE(Q3))**2*P**2*Y*M30*J30X*J30)+9.0D0*DSIN(DBLE(Q3))**2*P**2* . M30*J30Y**2-(9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Y*J10Y)+9.0D0* . DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J10Y T1=T1+9.0D0*DSIN(DBLE(Q3))**2*P**2*M30*J30Z*J30X-(9.0D0*DSIN(DBLE( . Q3))**2*P**2*M30*J10Y*J30X)-(DSIN(DBLE(Q3))**2*P**2*J30Y*M10*J30X . )+DSIN(DBLE(Q3))**2*P**2*J30Z*M10*J30X-(DSIN(DBLE(Q3))**2*Y*J30Y* . J30X*J30)+DSIN(DBLE(Q3))**2*J30Y**2*J30X-(DSIN(DBLE(Q3))**2*J30Y* . J10Y*J30X)+DSIN(DBLE(Q3))**2*J30Z*J10Y*J30X-(729.0D0*DCOS(DBLE(Q3 . ))**2*DCOS(DBLE(Q2))**2*P**6*M30**3) T1=T1-(81.0D0*DCOS(DBLE(Q3))**2*DCOS(DBLE(Q2))**2*P**4*M30**2*J30X . )+729.0D0*P**6*M30**3+81.0D0*P**6*M30**2*M10+81.0D0*P**4*M30**2* . J30Y+81.0D0*P**4*M30**2*J10Y+81.0D0*P**4*M30**2*J30X+9.0D0*P**4* . M30*J30Y*M10+9.0D0*P**4*M30*M10*J30X+9.0D0*P**2*M30*J30Y*J10Y+ . 9.0D0*P**2*M30*J30Y*J30X MIV(3,3)=(T0+9.0D0*P**2*M30*J10Y+P**2*J30Y*M10+J30Y*J10Y)/(T1+ . 9.0D0*P**2*M30*J10Y*J30X+P**2*J30Y*M10*J30X+J30Y*J10Y*J30X) DO 25007 J=1,3 DO 25008 K=J+1,3 M(K,J)=M(J,K) MIV(K,J)=MIV(J,K) 25008 CONTINUE 25007 CONTINUE \end{framedverbatim} \end{document}