* MATRIX - AFFINE TRANSFORM SUPPORT PACKAGE
*
* 
* AUTHOR:
* 
*       PHILIPP HACHTMANN
* 
* VERSIONS:
*               0.1 - INITIAL REVISION (22.12.2007
* 
*
* PURPOSE:
* 
* THIS LIBRARY PROVIDES AFFINE TRANSFORMATION ROUTINES TO
* PLOTTING ROUTINES AND OTHER SOFTWARE.
* 
* 
* DATA REPRESENTATION:
* 
* 
* MATRIX FORMAT:        | A11 A12 |
*                    M= |         |
*                       | A21 A22 |
*
* A11-A22 ARE SINGLE PRECISION FLOAT VALUES COMPLIANT TO THE
* HONEYWELL MATHEMATICAL LIBARAY. EVERY VALUE USES TWO 
* 16 BIT MACHINE WORDS.
* IF A MATRIX IS USED AS A DAC ARGUMENT, A POINTER TO THE FIRST
* ELEMENT, A11, HAS TO BE USED.
* 
* 
* VECTOR FORMAT:        | A1 |
*                    V= |    |
*                       | A2 |
* 
* A1 AND A2 ARE SIGNED INTEGER VALUES. EVERY VALUE USES ONE
* 16 BIT MACHINE WORD.
* IF A VECTOR IS USED AS A DAC ARGUMENT, A POINTER TO THE FIRST
* ELEMENT, A1, HAS TO BE USED.
* 
* 
* AFFINE TRANSFORM FORMAT:
* 
* AN AFFINE TRANSFORM CONSISTS OF A MATRIX FOR ROTATING AND SCALING
* AND A VECTOR VOR RELOCATION OF THE RESULT.
* A VECTOR IS TRANSFORMED BY FIRST MULTIPLYING THE MATRIX WITH IT
* AND THEN ADDING THE RELOCATION VECTOR:
* 
*                       | A11 A12 |   | VI1 |   | VT1 |
* VO = MT * VI + VT  =  |         | * |     | + |     |
*                       | A21 A22 |   | VI2 |   | VT2 |
* 
*       | VI1*A11 + VI2*A12 + VT1 |
*    =  |                         |
*       | VI1*A21 + VI2*A22 + VT2 |
* 
* MT AND VT ARE THE TRANSFORMATION MATRIX AND VECTOR, VI THE INPUT
* VECTOR, VO THE RESULT VECTOR.
* 
* AN AFFINE TRANSFORM IS STORED AS A CONCATENATION OF A MATRIX AND
* A VECTOR. HERE IS THE MEMORY LAYOUT:
* 
* '000 : MT11 UPPER
* '001 : MT11 LOWER
* '002 : MT12 UPPER
* '003 : MT12 LOWER
* '004 : MT21 UPPER
* '005 : MT21 LOWER
* '006 : MT22 UPPER
* '007 : MT22 LOWER
* '010 : VT1
* '011 : VT2
* 
* FOR EVERY TRANSFORMATION, '12 WORDS HAVE TO BE RESERVED.
* IN AN APPLICATION, A TRANFORMATION VARIABLE COULD BE 
* DECLARED WITH:
* 
*       TRANS   BSS     '12
* 
* 
* 
*********************************************************************************  
* 
* 
* 
* M$INIT: INITIALISE MATRIX TO IDENTITY
* 
* THE MATRIX ARGUMENT IS SET TO 
* 
*       		| 1.0  0.0 |
*                    M= |          |
*                       | 0.0  1.0 |
* 
* WHICH RESULTS TO THE IDENTITY TRANSFORMATION.
* 
*               JST     M$INIT
*               DAC     MATRIX  POINTER TO A MATRIX
*  
* 
* 
* M$MUL: MATRIX MULTIPLICATION
* 
*               JST     M$MUL
*               DAC     TARGET  POINTER TO TARGET MATRIX
*               DAC     MATRIX1 POINTER TO LEFT MATRIX
*               DAC     MATRIX2 POINTER TO RIGHT MATRIX
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
*  
* 
* M$APLI: APPLY MATRIX TO VECTOR
* 
* THIS ROUTINE CONVERTS THE VECTOR ELEMENTS TO FLOATING POINT VALUES,
* APPLIES THE TRANSFORMATION TO THEM AND ROUNDS THE RESULTS BACK TO
* INTEGER VALUES. THEN IT  SAVES THE NEW VECTOR TO THE LOCATION 
* DESIGNATED BY THE TARGET ADDRESS. SOURCE AND TARGET MAY BE THE SAME,
* THE SOURCE'S CONTENTS ARE NOT ALTERED.
*
*               JST     M$APLI
*               DAC     MATRIX  MATRIX TO APPLY
*               DAC     TARGET  POINTER TO TARGET VECTOR
*               DAC     SOURCE  VECTOR TO TRANSFORM
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
* 
* M$APII: APPLY MATRIX TO PAIR OF INTEGERS AS VECTOR
* 
* THIS ROUTINE USES TWO DISTINCT INTEGER POINTERS TO DESCRIBE A POINT.
* THE REST OF THE BEHAVIOR IS EXACTLY LIKE M$APL.
* 
*               JST     M$APII
*               DAC     MATRIX  MATRIX TO APPLY
*               DAC     XO      X COORDINATE OF RESULT VECTOR
*               DAC     XO      Y COORDINATE OF RESULT VECTOR
*               DAC     XI      X COORDINATE OF ARGUMENT VECTOR
*               DAC     YI      Y COORDINATE OF ARGUMENT VECTOR
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
* 
* M$ROT: ROTATE MATRIX
* 
* THIS ROUTINE TAKES A MATRIX AND ADDS A ROTATION TO IT.
* INTERNALLY, THE ROUTINE CREATES A ROTATION MATRIX AND THEN
* MULTIPLIES IT WITH THE ARGUMENT MATRIX. THE ROTATION IS SPECIFIED
* COUNTERCLOCKWISE FORWARD, ANGLE IN RADIANT.
* THE ANGLE ARGUMENT IS A SINGLE PRECISION FLOATING POINT NUMER
* TAKING TWO WORDS TO STORE.
* 
*               JST     M$ROT
*               DAC     MATRIX  MATRIX TO MODIFY
*               DAC     ANGLE   RADIANT ANGLE
*               DAC     0       FOR FORTRAN IV COMPATIBILITY 
* 
* 
* M$ROTI: ROTATE MATRIX
* 
* WORKS LIKE M$ROT, BUT TAKES AN INTEGER DEGREE VALUE AS ARGUMENT.
*  
*               JST     M$ROTI
*               DAC     MATRIX  MATRIX TO MODIFY
*               DAC     ANGLE   DEGREE ANGLE
*               DAC     0       FOR FORTRAN IV COMPATIBILITY 
* 
* 
* M$SCLE: SCALE MATRIX
* 
* THIS ROUTINE WORKS SIMILAR TO M$ROT BUT SCALES THE ARGUMENT MATRIX.
* THE SCALE FACTOR IS A FLOATING POINT NUMBER. LIKE THE ROTATION ANGLE.
* 
*               JST     M$SCLE
*               DAC     MATRIX  MATRIX TO MODIFY
*               DAC     SCALE   SCALE FACTOR
*               DAC     0       FOR FORTRAN IV COMPATIBILITY 
* 
* 
*********************************************************************************
* 
* 
* T$INIT: INITIALISE AFFINE TRANSFORM
*               
*               JST     T$INIT
*               DAC     TRANS   POINTER TO AFFINE TRANSFORMATION (SEE ABOVE)
* 
* 
* T$SCLE: SCALE AFFINE TRANSFORMATION
*               
* THIS SCALES THE MATRIX OF THE AFFINE TRANSFORMATION BY FACTOR SCALE.
* CALLS M$SCLE INTERNALLY.
* 
*               JST     T$SCLE
*               DAC     TRANS   TRANSFORMATION TO MODIFY
*               DAC     SCALE   SCALE FACTOR
*               DAC     0       FOR FORTRAN IV COMPATIBILITY 
* 
*  
* T$TRAN: ADD RELOCATION TO AFFINE TRANSFORMATION
* 
* THE OFFSET VECTOR IS FIRST PROCESSED BY THE TRANSFORMATION.
* THEN IT IS ADDED TO THE TRANSFORMATION'S TRANSLATION VECTOR.
* 
*               JST     T$TRAN
*               DAC     TRANS   TRANSFORMATION TO MODIFY   
*               DAC     XOFF    X OFFSET
*               DAC     YOFF    Y OFFSET
*               DAC     0       FOR FORTRAN IV COMPATIBILITY 
* 
* 
* T$ROT: ADD ROTATION TO AFFINE TRANSFORMATION
* 
* ADDS ROTATION TO THE MATRIX OF THE AFFINE TRANSFORMATION.
* CALLS M$$ROT INTERNALLY.
* 
*               JST     T$ROT
*               DAC     TRANS   TRANSFORMATION TO MODIFY
*               DAC     ANGLE   ANGLE LIKE FOR M$ROT
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
* 
* T$ROTI: ADD ROTATION TO AFFINE TRANSFORMATION
* USES AN INTEGER ARGUMENT INSTEAD OF FLOATING POINT RADIANT.
* 
* ADDS ROTATION TO THE MATRIX OF THE AFFINE TRANSFORMATION.
* CALLS M$$ROTI INTERNALLY.
* 
*               JST     T$ROTI
*               DAC     TRANS   TRANSFORMATION TO MODIFY
*               DAC     ANGLE   ANGLE LIKE FOR M$ROTI
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
* 
* T$APII: APPLY AFFINE TRANSFORM TO PAIR OF INTEGERS AS VECTOR
* 
* WORKS LIKE M$APII WHICH IS USED INTERNALLY.
*       
*               JST     T$APII
*               DAC     TRANS	TRANSFORMATION TO USE
*               DAC     XO      X COORDINATE OF RESULT VECTOR
*               DAC     XO      Y COORDINATE OF RESULT VECTOR
*               DAC     XI      X COORDINATE OF ARGUMENT VECTOR
*               DAC     YI      Y COORDINATE OF ARGUMENT VECTOR
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
*
* 
* T$APLI: APPLY AFFINE TRANSFORM TO VECTOR
* 
* WORKS LIKE M$APL WHICH IS USED INTERNALLY.
* 
*               JST     T$APLI
*               DAC     TRANS
*               DAC     TARGET  POINTER TO TARGET VECTOR
*               DAC     SOURCE  POINTER TO INPUT VECTOR
*               DAC     0       FOR FORTRAN IV COMPATIBILITY
* 
* 
*                   
********************************************************************************
*
**** EXPORTED SYMBOLS
* 
	SUBR	MATRIX,INIT	JUST A FANCY LABEL
	SUBR	M$INIT,INIT	INITIALISE MATRIX
	SUBR	M$MUL,MUL	MATRIX MULTIPLICATION
	SUBR	M$APLI,APLI	APPLY MATRIX TO INTEGER VECTOR
	SUBR	M$APII,APII	APPLY MATRIX TO PAIR OF INTEGERS
	SUBR	M$ROT,ROT	ADD ROTATION TO MATRIX
	SUBR	M$ROTI,ROTI	ADD ROTATION TO MATRIX
	SUBR	M$SCLE,SCLE	SCALE MATRIX
	SUBR	M$SCLI,SCLI	SCALE MATRIX (INTEGER PERCENT)
*
	SUBR	T$INIT,AFIN	INITIALISE AFFINE TRANSFORMATION
	SUBR	T$APLI,TPLI	APPLY AFFINE TRANSFORM TO INTEGER VECTOR
	SUBR	T$APII,TPII	APPLY AFFINE TRANSFORM TO PAIR OF INTEGERS
	SUBR	T$ROT,ROT	ADD ROTATION TO AFFINE TRANSFORMATION
	SUBR	T$ROTI,ROTI	ADD ROTATION TO AFFINE TRANSFORMATION
	SUBR	T$SCLE,SCLE	SCALE AFFINE TRANSFORMATION
	SUBR	T$SCLI,SCLI	SCALE AFFINE TRANSFORMATION (INTEGER PERCENT)
	SUBR	T$TRAN,TRAN	ADD TRANSLATION TO AFFINE TRANSFORMATION
*  
*  
********************************************************************************
* 
* 
	REL			RELOCATEABLE MODE
* 
* 
********************************************************************************
* 
* 
*** T$TRAN - TRANSLATE
* 
* 
*	ABS
*	ORG	'4000
TRAN	DAC	**	ENTRY.
	LDA*	TRAN	TRANSFORMATION POINTER
	STA	TPT
	ADD	=8
	STA	VECP
	IRS	TRAN
* 
	LDA*	TRAN	X OFFSET
	STA	XOFP
	IRS	TRAN	
* 
	LDA*	TRAN	Y OFFSET
	STA	YOFP
	IRS	TRAN
* 
	IRS	TRAN	FOR FORTRAN IV
* 
	JST	APII	FIXME!
TPT	DAC	**
	DAC	TMP3	STORE NEW X VALUE IN TMP3
	DAC	TMP4	STORE NEW Y VALUE IN TMP4
XOFP	DAC	**
YOFP	DAC	**
	DAC	0	FOR FORTRAN IV COMPATIBILITY
* 
	LDA*	VECP
	ADD	TMP3
	STA*	VECP
	IRS	VECP
	LDA*	VECP
	ADD	TMP4
	STA*	VECP
* 
	JMP*	TRAN	RETURN.
* 
* 
********************************************************************************
* 
* 
**** T$APLI - APPLY AFFINE TRANSFORMATION TO INTEGER VECTOR
* 
* USED VARIABLES: ((TMP1) XOP,YOP,XP1,YP1,XP2,YP2),VECP
* 
TPLI	DAC	**	ENTRY.
* 
	LDA*	TPLI	LOAD POINTER TO TRANSFORMATION
	STA	MPT	STORE TO MATRIX POINTER
	ADD	=8	FORWARD TO VECTOR ADDRESS IN TRANSFORMATION
	STA	VECP	VECTOR ADDRESS
	IRS	TPLI
*  
	LDA*	TPLI	POINTER TO RESULT VECTOR
	STA	IOV
	IRS	TPLI
* 
	LDA*	TPLI	POINTER TO INPUT VECTOR
	STA	IIV
	IRS	TPLI
* 
	IRS	TPLI
*  
	JST	APLI	APPLY MATRIX
MPT	DAC	**
IOV	DAC	**
IIV	DAC	**
* 
	LDA*	IOV	PERFORM VECTOR ADDITION
	ADD*	VECP
	STA*	IOV
	IRS	VECP
	IRS	IOV
	LDA*	IOV
	ADD*	VECP
	STA*	IOV
* 
	JMP*	TPLI
* 
* 
********************************************************************************
* 
* 
**** T$APII - APPLY AFFINE TRANSFORMATION TO PAIR OF INTEGERS
* 
* USED VARIABLES: ((TMP1) XOP,YOP,XP1,YP1,XP2,YP2),VECP
* 
* 
****************************************
* 
TPII	DAC	**	ENTRY.
* 
	LDA*	TPII	LOAD POINTER TO TRANSFORMATION
	STA	IMPT	STORE TO MATRIX POINTER
	ADD	=8	FORWARD TO VECTOR ADDRESS IN TRANSFORMATION
	STA	VECP	VECTOR ADDRESS
	IRS	TPII
*  
	LDA*	TPII	POINTER TO RESULT X
	STA	RXP
	IRS	TPII
* 
	LDA*	TPII	POINTER TO RESULT Y
	STA	RYP
	IRS	TPII
* 
	LDA*	TPII	POINTER TO INPUT X
	STA	IXP
	IRS	TPII
* 
	LDA*	TPII	POINTER TO INPUT Y
	STA	IYP
	IRS	TPII
* 
	IRS	TPII
*  
	JST	APII	APPLY MATRIX
IMPT	DAC	**
RXP	DAC	**	
RYP	DAC	**
IXP	DAC	**
IYP	DAC	**
	DAC	0
* 
	LDA*	VECP	PERFORM THE ADDITION
	ADD*	RXP
	STA*	RXP
	IRS	VECP
	LDA*	VECP
	ADD*	RYP
	STA*	RYP
* 
	JMP*	TPII	RETURN
* 
* 
********************************************************************************
* 
* 
**** INITIALIZE AFFINE TRANSFORMATION
* 
AFIN	DAC	**
	LDA*	AFIN
	STA	AFI1	STORE ARGUMENT POINTER
	LDX	AFIN	LOAD INTO INDEX REGISTER, TOO
	IRS	AFIN	TALLY RETURN ADDRESS
* 
	JST	INIT	MATRIX INIT
AFI1	DAC	**	
* 
	CRA
	STA	8,1	CLEAR FIRST VECTOR ELEMENT
	STA	9,1	CLEAR SECOND VECTOR ELEMENT
* 
	JMP*	AFIN	RETURN TO CALLER
* 
* 
********************************************************************************
* 
*
**** INITIALIZE MATRIX
* 
*       THIS ROUTINE SHOULD BE IMPROVED BY SUPPLYING
*       A FLOATING POINT 1.0 CONSTANT! 
* 
****************************************
* 
INIT	DAC	**
	LDX*	INIT	LOAD INDEX REGISTER WITH ADDRESS OF MATRIX
	IRS	INIT	CORRECT RETURN ADDRESS
*
	CRA		INITIALISE
	STA	1,1	A11, LOWER BITS
	STA	2,1	A12
	STA	3,1	          
	STA	4,1	A21
	STA	5,1
	STA	7,1	A22, LOWER BITS	
* 
	LDA	ONEF	FLOATING POINT 1.0 CONSTANT
	STA	0,1	A11, UPPER BITS
	STA	6,1	A22, UPPER BITS
* 
	JMP*	INIT	RETURN.
* 
* 
********************************************************************************
* 
* 
**** MATRIX MULTIPLICATION
* 
*     C =      A      *      B
*
*         | a11 a12 |   | b11 b12 |
*       = |         | * |         |
*         | a21 a22 |   | b21 b22 |   
*
*         | (a11*b11) (a21*b12) |
*       = |                     |
*         | (a12*b21) (a22*b22) |
* 
* CALL:
*       JST MUL
*       DAC MC
*       DAC MA
*       DAC MB
*
****************************************
* 
MUL	DAC	**
	LDX*	MUL
*
	LDA*	MUL
	STA	PC11
	ADD	=2
	STA	PC12
	ADD	=2
	STA	PC21
	ADD	=2
	STA	PC22
	IRS	MUL
*
	LDA*	MUL
	STA	PA11
	ADD	=2
	STA	PA12
	ADD	=2
	STA	PA21
	ADD	=2
	STA	PA22
	ADD	=2
*
	IRS	MUL
*
	LDA*	MUL
	STA	PB11
	ADD	=2
	STA	PB12
	ADD	=2
	STA	PB21
	ADD	=2
	STA	PB22
	ADD	=2
*
	IRS	MUL
	IRS	MUL
*
*  a11 a12  b11 b12   a11*b11 a21*b12
*  a21 a22  b21 b22   a12*b21 a22*b22
*
	CALL	L$22	LOAD REAL
PA11	DAC	0
	CALL	M$22	MULTIPLY
PB11	DAC	0
	CALL	H$22	STORE
PC11	DEC	0
*
	CALL	L$22
PA21	DEC	0
	CALL	M$22
PB12	DEC	0
	CALL	H$22
PC12	DEC	0
*
	CALL	L$22
PA12	DEC	0
	CALL	M$22
PB21	DEC	0
	CALL	H$22
PC21	DEC	0
*
	CALL	L$22
PA22	DEC	0
	CALL	M$22
PB22	DEC	0
	CALL	H$22
PC22	DEC	0
*
*
	JMP*	MUL	RETURN.
*
* 
********************************************************************************
*
*
**** SCALE MATRIX
* 
SCLE	DAC	**	SCALE MATRIX
*	
	LDA*	SCLE	GET MATRIX BASE ADDRESS
	STA	SM11
	STA	TM11
	ADD	=2
	STA	SM12
	STA	TM12
	ADD	=2
	STA	SM21
	STA	TM21
	ADD	=2
	STA	SM22
	STA	TM22
	IRS	SCLE
	LDA*	SCLE
	STA	S1
	STA	S2
	STA	S3
	STA	S4
	IRS	SCLE	TALLY RETURN ADDRESS
	IRS	SCLE	AGAIN
*
	CALL	L$22
SM11	DAC	**
	CALL	M$22
S1	DAC	**
	CALL	H$22
TM11	DAC	**
*
	CALL	L$22
SM12	DAC	**
	CALL	M$22
S2	DAC	**
	CALL	H$22
TM12	DAC	**
*
	CALL	L$22
SM21	DAC	**
	CALL	M$22
S3	DAC	**
	CALL	H$22
TM21	DAC	**
*
	CALL	L$22
SM22	DAC	**
	CALL	M$22
S4	DAC	**
	CALL	H$22
TM22	DAC	**
*
	JMP*	SCLE
*
*
********************************************************************************
* 
* 
**** ADD ROTATION TO MATRIX
*
*  
*    M =      M      *          MROT
* 
*        | M11 M12 |   | COS(X)  -SIN(X)|
*      = |         | * |                |
*        | M21 M22 |   | SIN( X)  COS(X)|
* 
*        | M11*COS(X)+M12*SIN(X)  M12*COS(X)-M11*SIN(X) |
*      = |                                              |
*        | M21*COS(X)+M22*SIN(X)  M22*COS(X)-M21*SIN(X) |
* 
* CALL:
*       JST     ROT
*       DAC     MATRIX
*       DAC     ANGLE
*       DAC     0       DON'T FORGET!
* 
****************************************
* 
ROT	DAC	**	ENTRY
* 
	LDA*	ROT	GET MATRIX POINTER
	STA	R111	M11, FIRST COPY
	STA	R211	M11, SECOND COPY
	STA	R311	M11, THIRD COPY
	ADD	=2
	STA	R112
	STA	R212
	STA	R312
	STA	R412
	ADD	=2
	STA	R121
	STA	R221
	STA	R321
	ADD	=2
	STA	R122
	STA	R222
	STA	R322
	IRS	ROT
	LDA*	ROT
	STA	RA1
	STA	RA2
	IRS	ROT
	IRS	ROT
* 
* 
**** M11 CALCULATION
* 
	CALL	SIN	FLOATING POINT SINE
RA1	DAC	**	POINTER TO ANGLE
	CALL	H$22	SAVE TO TMP1
	DAC	TMP1
*	CALL	L$22
*	DAC	TMP1
	CALL	M$22	MULTIPLY
R112	DAC	**	M12
	CALL	H$22	STORE TO TMP3
	DAC	TMP3
* 
*************************************
* 
	CALL	COS	FLOATING POINT COSINE
RA2	DAC	**	POINTER TO ANGLE	
	CALL	H$22	SAVE TO TMP2
	DAC	TMP2
	CALL	M$22	MULTIPLY
R111	DAC	**	M11
	CALL	A$22	ADD TMP3
	DAC	TMP3
	CALL	H$22	SAVE NEW M11 TO TMP3
	DAC	TMP3
* 
* 
* M12 CALCULATION
* 
* M12 = M12*COS(X)-M11*SIN(X)
* 
*  
	CALL	L$22	LOAD SINE
	DAC	TMP1
	CALL	M$22	MULTIPLY
R211	DAC	**	M11
	CALL	H$22	STORE TO TMP4
	DAC	TMP4
	CALL	L$22	LOAD COSINE
	DAC	TMP2
	CALL	M$22	MULTIPLY
R212	DAC	**
* 
	CALL	S$22	SUBSTRACT !!
	DAC	TMP4
* 
	CALL	H$22	SAVE TO NEW M12
R312	DAC	**
*
 	CALL	L$22	LOAD NEW M11 FROM TMP3
	DAC	TMP3
	CALL	H$22	AND SAVE TO NEW M11
R311	DAC	**
* 
* 
* ******************************************
* 
* M21 CALCULATION
* 
* M21*COS(X)+M22*SIN(X)
* 
* M22*SIN(X) -> TMP3
* M21*COS(X) - TMP3
* 
* 
*    
	CALL	L$22	LOAD SINE
	DAC	TMP1
	CALL	M$22	MULTIPLY
R122	DAC	**	M22
	CALL	H$22	STORE TO TMP3
	DAC	TMP3
	CALL	L$22	LOAD COSINE
	DAC	TMP2
	CALL	M$22	MULTIPLY
R121	DAC	**	M11
	CALL	A$22	ADD TMP3
	DAC	TMP3
	CALL	H$22	SAVE NEW M21 TO TMP3
	DAC	TMP3
*
* M22 CALCULATION
* 
* M22*COS(X)-M21*SIN(X)
* 
* 
* 	JMP	NN	
	CALL	L$22	LOAD SINE
	DAC	TMP1
	CALL	M$22	MULTIPLY
R221	DAC	**	M21
	CALL	H$22	STORE TO TMP4
	DAC	TMP4
	CALL	L$22	LOAD COSINE
	DAC	TMP2
	CALL	M$22	MULTIPLY
R222	DAC	**
	CALL	S$22	SUBSTRACT
	DAC	TMP4
	CALL	H$22	SAVE TO NEW M22
R322	DAC	**
	CALL	L$22	LOAD NEW M21 FROM TMP3
	DAC	TMP3
	CALL	H$22	AND SAVE TO NEW M21
R321	DAC	**
* 
*        
	JMP*	ROT	RETURN.
*
R412	DAC	**
*  
********************************************************************************
*
*
**** APPLY MATRIX TO PAIR OF INTEGERS
*
*       SETS UP MATRIX POINTERS AND VECTOR POINTERS. 
*       THEN IT CALLS APL, THE REAL WORKING ROUTINE.
* 
* CALL:
*       JST     M$APII
*       DAC     MATRIX
*       DAC     XO	
*       DAC     YO
*       DAC     XI	
*       DAC     YI
*       DAC     0       DON'T FORGET!
* 
* USED VARIABLES: (TMP1) XOP,YOP,XP1,YP1,XP2,YP2
* 
****************************************
*
APII	DAC	**
*
	LDA*	APII	POINTER TO MATRIX
	STA	MP11	STORE M11
	ADD	=2	ADD 2
	STA	MP12	STORE M12
	ADD	=2	ADD 2
	STA	MP21	STORE M21
	ADD	=2	ADD 2
	STA	MP22	STORE M22
	IRS	APII	JUMP TO NEXT ARGUMENT (X)
*
	LDA*	APII	LOAD X VALUE
	STA	XOP	STORE TO X-POINTER
	IRS	APII	JUMP TO NEXT ARGUMENT (Y)
	LDA*	APII	LOAD Y VALUE
	STA	YOP	STORE TO Y-POINTER
	IRS	APII	CORRECT RETURN ADDRESS
* 
	LDA*	APII	LOAD X VALUE
	STA	XIP1	STORE TO X-POINTER
	STA	XIP2	STORE TO X-POINTER
	IRS	APII	JUMP TO NEXT ARGUMENT (Y)
	LDA*	APII	LOAD Y VALUE
	STA	YIP1	STORE TO Y-POINTER
	STA	YIP2	STORE TO Y-POINTER
	IRS	APII	CORRECT RETURN ADDRESS
* 
	IRS	APII	FOR FORTRANIV COMPATIBILITY
	JST	APL	CALL REAL ROUTINE
	JMP*	APII
*	
********************************************************************************
*
*
**** APPLY MATRIX TO VECTOR
* 
* SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
* THE REAL WORKING ROUTINE.
*
* CALL:
*       JST     M$APLI
*       DAC     MATRIX
*       DAC	TARGET
*       DAC     SOURCE
*       DAC     0       DON'T FORGET!
* 
* USED VARIABLES: (TMP1) XOP,YOP,XP1,YP1,XP2,YP2
* 
****************************************
*
APLI	DAC	**
* 
	LDA*	APLI
	STA	MP11
	ADD	=2
	STA	MP12
	ADD	=2
	STA	MP21
	ADD	=2
	STA	MP22
	IRS	APLI
*
	LDA*	APLI
	STA	XOP
	AOA
	STA	YOP
	IRS	APLI
* 
	LDA*	APLI
	STA	XIP1
	STA	XIP2
	AOA
	STA	YIP1
	STA	YIP2
	IRS	APLI
* 
	IRS	APLI
	JST	APL	CALL INTERNAL ROUTINE
	JMP*	APLI	RETURN.
*
*
********************************************************************************
*
*
**** INTERNAL ROUTINE OF M$APL AND M$APII.
* 
* ALL DATA IS SET UP BY THE BOTH USER ROUTINES ABOVE.
* 
* USED VARIABLES: TMP1
* 
****************************************
* 
APL	DAC	**	
*
	CALL	FLOAT	LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER
XIP1	DAC	0
	CALL	M$22	MULTIPLY FLOAT*FLOAT
MP11	DAC	0
	CALL	H$22	STORE FLOAT
	DAC	TMP1
	CALL	FLOAT
YIP1	DAC	0
	CALL	M$22
MP12	DAC	0
	CALL	A$22
	DAC	TMP1
	JST	RND	ROUND AND CONVERT TO INTEGER
	STA	PA21	STORE NEW X VALUE INTO TEMPORARY LOCATION
****
	CALL	FLOAT
XIP2	DAC	0
	CALL	M$22
MP21	DAC	0
	CALL	H$22
	DAC	TMP1
*
	CALL	FLOAT
YIP2	DAC	0
	CALL	M$22
MP22	DAC	0
	CALL	A$22
	DAC	TMP1
	JST	RND	NOW INTEGER IN AC
	STA*	YOP	STORE NEW Y VALUE
*
	LDA	PA21
	STA*	XOP
* 
	JMP*	APL	RETURN TO CALLER.
*
* 
********************************************************************************
* 
* 
**** M$ROTI ROTATE MATRIX, USE INTEGER DEGREE ANGLE
* 
ROTI	DAC	**
	LDA*	ROTI	GET MATRIX POINTER
	STA	MTA	STORE TO ARGUMENT TO FINAL ROT
	IRS	ROTI	NEXT ARGUMENT: ANGLE
	LDA*	ROTI	LOAD ANGLE
	IRS	ROTI	
	IRS	ROTI
	JST	RAD	CONVERT INTEGER TO RADIANT
	CALL	H$22
	DAC	RTMP
	JST	ROT
MTA	DAC	**
	DAC	RTMP
	DAC	0	
	JMP*	ROTI
* 
RTMP	BSS	2	TEMPORARY VARIABLE
* 
* 
********************************************************************************
* 
* 
**** M$SCLI - SCALE MATRIX, USE INTEGER PERCENT VALUE
* 
SCLI	DAC	**
	LDA*	SCLI	GET MATRIX POINTER
	STA	MTSS	STORE TO ARGUMENT TO FINAL ROT
	IRS	SCLI	NEXT ARGUMENT: PERCENTS
* 
	LDA*	SCLI	LOAD PERCENTS
	STA	SA1	STORE
	CALL	FLOAT	CONVERT TO FLOAT
SA1	DAC	**
	CALL	M$22	MULTIPLY WITH
	DAC	PERC	FACTOR 0.01
	IRS	SCLI	
	IRS	SCLI
	CALL	H$22
	DAC	RTMP
* 
	JST	SCLE
MTSS	DAC	**
  	DAC	RTMP
	DAC	0
* 
	JMP*	SCLI	RETURN
* 
* 
********************************************************************************
*
* 
**** ROUND FLOAT TO INTEGER ROUTINE
* 
* THERE IS NO CORRECTLY WORKING ROUNDING ROUTINE IN THE LIBRARY.
* SO THIS IS A WORKAROUND. ADDS 0.5 TO THE VALUE AND USES ONE
* ONE OF THE TRUNCATE AND CONVERT ROUTINES.
* THE ARGUMENT IS IN REGISTERS A/B, THE RESULT IS PUT INTO A.
* 
****************************************
* 
RND	DAC	**	
	CALL	A$22	ADD 
	DAC	HLF	    0.5
	CALL	C$21	TRUNCATE TO INTEGER
	NOP
	JMP*	RND
* 
* 
********************************************************************************
* 
* 
**** RAD - CONVERT ANGLE IN DEGREE TO RADIANT.
* 
* ENTER WITH INTEGER ANGLE IN A
* 
* CALL:
* 
*       JST     RAD
*       DAC     ANGLE   POINTER TO ANGLE
* 
****************************************
* 
RAD	DAC	**
	STA	AN1
	CALL	FLOAT
AN1	DAC	**
	CALL	M$22
	DAC	DEG
	JMP*	RAD
* 
*  
********************************************************************************
* 
* 
**** CONSTANTS
* 
ONE	DEC	1
HLF	OCT	'040100	CONSTANT 0.5	
	OCT	'000000
ONEF	OCT	'040300	CONSTANT 1.0
	OCT	'000000
DEG	OCT	'036707	CONSTANT PI/180
	OCT	'076432
PERC	OCT	'036521	CONTANT 0.01
	OCT	'165605
* 
* 
********************************************************************************
* 
* 
**** VARIABLES
* 
TMP1	BSS	'2	TEMPORARY 2-WORD VARIABLE
TMP2	BSS	'2	      "      "      "
TMP3	BSS	'2	      "      "      "   
TMP4	BSS	'2	      "      "      "
VAP	DAC	**	TEMPORARY POINTER TO VECTOR
XOP	DAC	**	OUTPUT VECTOR X POINTER
YOP	DAC	**	OUTPUT VECTOR Y POINTER
*VECP	DAC	**	VECTOR POINTER USED BY T$PII,T$PLI
VECP	EQU	TMP2	VECTOR POINTER USED BY T$PII,T$PLI
* 
*
********************************************************************************
*
* 
**** END OF THE LINE
* 
	END
*
* 
********************************************************************************