[h316.git] / lib / hachti / src / matrix.asm

* 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 |
* 
* WICH 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 IN THE PLACE OF THE 
* OLD VECTOR.
*
*               JST     M$APLI
*               DAC     MATRIX  MATRIX TO APPLY
*               DAC     VECTOR  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 INSTEAD OF ONE VECTOR
* POINTER. THE REST OF THE BEHAVIOR IS EXACTLY LIKE M$APL.
* 
*               JST     M$APLI
*               DAC     MATRIX  MATRIX TO APPLY
*               DAC     X       X COORDINATE OF ARGUMENT VECTOR
*               DAC     Y       Y COORDINATE OF ARGUMENT VECTOR
* 
* 
* 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
* 
* 
* 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
* 
*                
********************************************************************************
*
**** 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$SCLE,SCLE	SCALE MATRIX
*
	SUBR	A$INIT,AFIN	INITIALISE AFFINE TRANSFORMATION
* 
*  
********************************************************************************
* 
* 
	REL			RELOCATEABLE MODE
* 
* 
********************************************************************************
*
* 
**** 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
	LDA*	INIT	LOAD MATRIX ADDRESS
	STA	IM11	STORE POINTER TO FIRST ELEMENT (A11)
	ADD	=6	IM12,IM21 ARE NOT TO BE INITIALISED WITH FP DATA
	STA	IM22	STORE POINTER TO FOURTH ELEMENT (A22)
	IRS	INIT	CORRECT RETURN ADDRESS
*
	CRA		INITIALISE
	STA	2,1	A12
	STA	3,1	          
	STA	4,1	A21
	STA	5,1	
	CALL	FLOAT	GENERATE FLOATING POINT 1.0
	DAC	ONE	CONSTANT INTEGER 1
	CALL	H$22	STORE FLOATING POINT	
IM11	DEC	0
	CALL	H$22
IM22	DEC	0
*
	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
	LDX*	SCLE
*	
	LDA*	SCLE	GET MATRIX BASE ADDRESS
	STA	SM11
	STA	TM11
	ADD	=6
	STA	SM22
	STA	TM22
	IRS	SCLE
	LDA*	SCLE
	STA	SX
	STA	SY
	IRS	SCLE	TALLY RETURN ADDRESS
*
	CALL	L$22
SM11	DAC	0
	CALL	M$22
SX	DAC	0
	CALL	H$22
TM11	DAC	0
*
	CALL	L$22
SM22	DAC	0
	CALL	M$22
SY	DAC	0
	CALL	H$22
TM22	DAC	0
*
	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
	ADD	=2
	STA	R112
	STA	R212
	ADD	=2
	STA	R121
	STA	R221
	ADD	=2
	STA	R122
	STA	R222
	IRS	ROT
	STA	RA1
	STA	RA2
	IRS	ROT
	IRS	ROT
* 
* 
	CALL	SINX1	FLOATING POINT SINE
RA1	DAC	**	POINTER TO ANGLE
	LDA	='77
	HLT
	CALL	H$22	SAVE TO TMP1
	DAC	TMP1
	CALL	M$22	MULTIPLY
R112	DAC	**	M12
	CALL	H$22	STORE TO TMP3
	DAC	TMP3
	CALL	COSX1	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
* 
	CALL	L$22	LOAD SINE
	DAC	TMP1
	CALL	M$22	MULTIPLY
R212	DAC	**	M12
	CALL	H$22	STORE TO TMP4
	DAC	TMP4
	CALL	L$22	LOAD COSINE
	CALL	M$22	MULTIPLY
R211	DAC	**
	CALL	S$22	SUBSTRACT
	DAC	TMP4
	CALL	H$22	SAVE TO NEW M12
R312	DAC	**
	CALL	L$22	LOAD NEW M11 FROM TMP3
	CALL	H$22	AND SAVE TO NEW M11
R311	DAC	**
* 
* 
	CALL	L$22	LOAD SINE
	CALL	M$22	MULTIPLY
R122	DAC	**	M12
	CALL	H$22	STORE TO TMP3
	DAC	TMP3
	CALL	H$22	LOAD COSINE
	DAC	TMP2
	CALL	M$22	MULTIPLY
R121	DAC	**	M11
	CALL	A$22	ADD TMP3
	DAC	TMP3
	CALL	H$22	SAVE NEW M11 TO TMP3
	DAC	TMP3
* 
	CALL	L$22	LOAD SINE
	DAC	TMP1
	CALL	M$22	MULTIPLY
R222	DAC	**	M12
	CALL	H$22	STORE TO TMP4
	DAC	TMP4
	CALL	L$22	LOAD COSINE
	CALL	M$22	MULTIPLY
R221	DAC	**
	CALL	S$22	SUBSTRACT
	DAC	TMP4
	CALL	H$22	SAVE TO NEW M12
R322	DAC	**
	CALL	L$22	LOAD NEW M11 FROM TMP3
	CALL	H$22	AND SAVE TO NEW M11
R321	DAC	**
* 
* 
	JMP*	ROT	RETURN.
* 
*  
********************************************************************************
*
*
**** 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     X	
*       DAC     Y
*       DAC     0       DON'T FORGET!
* 
****************************************
*
APII	DAC	**
*
	LDA*	APII
	STA	MP11
	ADD	=2
	STA	MP12
	ADD	=2
	STA	MP21
	ADD	=2
	STA	MP22
	IRS	APII
*
	LDA*	APII
	STA	XP1
	STA	XP2
	IRS	APII
	LDA*	APII
	STA	YP1
	STA	YP2
	IRS	APII
	IRS	APII
	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     VECTOR
*       DAC     0       DON'T FORGET!
* 
****************************************
*
APLI	DAC	**
* 
	LDA*	APLI
	STA	MP11
	ADD	=2
	STA	MP12
	ADD	=2
	STA	MP21
	ADD	=2
	STA	MP22
	IRS	APLI
*
	LDA*	APLI
	STA	XP1
	STA	XP2
	AOA
	STA	YP1
	STA	YP2
	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.
* 
****************************************
* 
APL	DAC	**	
*
	CALL	FLOAT	LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER
XP1	DAC	0
	CALL	M$22	MULTIPLY FLOAT*FLOAT
MP11	DAC	0
	CALL	H$22	STORE FLOAT
	DAC	TMP1
	CALL	FLOAT
YP1	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
XP2	DAC	0
	CALL	M$22
MP21	DAC	0
	CALL	H$22
	DAC	TMP1
*
	CALL	FLOAT
YP2	DAC	0
	CALL	M$22
MP22	DAC	0
	CALL	A$22
	DAC	TMP1
	JST	RND	NOW INTEGER IN AC
	STA*	YP1	STORE NEW Y VALUE
*
	LDA	PA21
	STA*	XP1
	JMP*	APL	RETURN TO CALLER.
*
* 
********************************************************************************
*
* 
**** 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
* 
* 
********************************************************************************
* 
* 
**** CONSTANTS
* 
ONE	DEC	1
HLF	OCT	'040100	CONSTANT 0.5	
	OCT	'000000
* 
* 
********************************************************************************
* 
**** VARIABLES
* 
TMP1	BSS	'2	TEMPORARY 2-WORD VARIABLE
TMP2	BSS	'2	      "      "      "
TMP3	BSS	'2	      "      "      "   
TMP4	BSS	'2	      "      "      "      
*
*
********************************************************************************
*
* 
**** END OF THE LINE
* 
	END
*
* 
********************************************************************************
Commit	Line	Data
13f9c770	1	* MATRIX - AFFINE TRANSFORM SUPPORT PACKAGE
	2	*
	3	*
	4	* AUTHOR:
	5	*
	6	* PHILIPP HACHTMANN
	7	*
	8	* VERSIONS:
	9	* 0.1 - INITIAL REVISION (22.12.2007
	10	*
	11	*
	12	* PURPOSE:
	13	*
	14	* THIS LIBRARY PROVIDES AFFINE TRANSFORMATION ROUTINES TO
	15	* PLOTTING ROUTINES AND OTHER SOFTWARE.
	16	*
	17	*
	18	* DATA REPRESENTATION:
	19	*
	20	*
	21	* MATRIX FORMAT: \| A11 A12 \|
	22	* M= \| \|
	23	* \| A21 A22 \|
	24	*
	25	* A11-A22 ARE SINGLE PRECISION FLOAT VALUES COMPLIANT TO THE
	26	* HONEYWELL MATHEMATICAL LIBARAY. EVERY VALUE USES TWO
	27	* 16 BIT MACHINE WORDS.
	28	* IF A MATRIX IS USED AS A DAC ARGUMENT, A POINTER TO THE FIRST
	29	* ELEMENT, A11, HAS TO BE USED.
	30	*
	31	*
	32	* VECTOR FORMAT: \| A1 \|
	33	* V= \| \|
	34	* \| A2 \|
	35	*
	36	* A1 AND A2 ARE SIGNED INTEGER VALUES. EVERY VALUE USES ONE
	37	* 16 BIT MACHINE WORD.
	38	* IF A VECTOR IS USED AS A DAC ARGUMENT, A POINTER TO THE FIRST
	39	* ELEMENT, A1, HAS TO BE USED.
	40	*
	41	*
	42	* AFFINE TRANSFORM FORMAT:
	43	*
	44	* AN AFFINE TRANSFORM CONSISTS OF A MATRIX FOR ROTATING AND SCALING
	45	* AND A VECTOR VOR RELOCATION OF THE RESULT.
	46	* A VECTOR IS TRANSFORMED BY FIRST MULTIPLYING THE MATRIX WITH IT
	47	* AND THEN ADDING THE RELOCATION VECTOR:
	48	*
	49	* \| A11 A12 \| \| VI1 \| \| VT1 \|
	50	* VO = MT * VI + VT = \| \| * \| \| + \| \|
	51	* \| A21 A22 \| \| VI2 \| \| VT2 \|
	52	*
	53	* \| VI1A11 + VI2A12 + VT1 \|
	54	* = \| \|
	55	* \| VI1A21 + VI2A22 + VT2 \|
	56	*
	57	* MT AND VT ARE THE TRANSFORMATION MATRIX AND VECTOR, VI THE INPUT
	58	* VECTOR, VO THE RESULT VECTOR.
	59	*
	60	* AN AFFINE TRANSFORM IS STORED AS A CONCATENATION OF A MATRIX AND
	61	* A VECTOR. HERE IS THE MEMORY LAYOUT:
	62	*
	63	* '000 : MT11 UPPER
	64	* '001 : MT11 LOWER
65	* '002 : MT12 UPPER
66	* '003 : MT12 LOWER
67	* '004 : MT21 UPPER
68	* '005 : MT21 LOWER
69	* '006 : MT22 UPPER
70	* '007 : MT22 LOWER
71	* '010 : VT1
72	* '011 : VT2
73	*
74	* FOR EVERY TRANSFORMATION, '12 WORDS HAVE TO BE RESERVED.
75	* IN AN APPLICATION, A TRANFORMATION VARIABLE COULD BE
76	* DECLARED WITH:
77	*
78	* TRANS BSS '12
79	*
80	*
81	*
82	*********************************************************************************
83	*
84	*
85	*
86	* M$INIT: INITIALISE MATRIX TO IDENTITY
87	*
88	* THE MATRIX ARGUMENT IS SET TO
89	*
90	* \| 1.0 0.0 \|
91	* M= \| \|
92	* \| 0.0 1.0 \|
93	*
94	* WICH RESULTS TO THE IDENTITY TRANSFORMATION.
95	*
96	* JST M$INIT
97	* DAC MATRIX POINTER TO A MATRIX
98	*
99	*
100	*
101	* M$MUL: MATRIX MULTIPLICATION
102	*
103	* JST M$MUL
104	* DAC TARGET POINTER TO TARGET MATRIX
105	* DAC MATRIX1 POINTER TO LEFT MATRIX
106	* DAC MATRIX2 POINTER TO RIGHT MATRIX
107	* DAC 0 FOR FORTRAN IV COMPATIBILITY
108	*
109	*
110	*
111	* M$APLI: APPLY MATRIX TO VECTOR
112	*
113	* THIS ROUTINE CONVERTS THE VECTOR ELEMENTS TO FLOATING POINT VALUES,
114	* APPLIES THE TRANSFORMATION TO THEM AND ROUNDS THE RESULTS BACK TO
115	* INTEGER VALUES. THEN IT SAVES THE NEW VECTOR IN THE PLACE OF THE
116	* OLD VECTOR.
117	*
118	* JST M$APLI
119	* DAC MATRIX MATRIX TO APPLY
120	* DAC VECTOR VECTOR TO TRANSFORM
121	* DAC 0 FOR FORTRAN IV COMPATIBILITY
122	*
123	*
124	* M$APII: APPLY MATRIX TO PAIR OF INTEGERS AS VECTOR
125	*
126	* THIS ROUTINE USES TWO DISTINCT INTEGER POINTERS INSTEAD OF ONE VECTOR
127	* POINTER. THE REST OF THE BEHAVIOR IS EXACTLY LIKE M$APL.
128	*
129	* JST M$APLI
130	* DAC MATRIX MATRIX TO APPLY
131	* DAC X X COORDINATE OF ARGUMENT VECTOR
132	* DAC Y Y COORDINATE OF ARGUMENT VECTOR
133	*
134	*
135	* M$ROT: ROTATE MATRIX
136	*
137	* THIS ROUTINE TAKES A MATRIX AND ADDS A ROTATION TO IT.
138	* INTERNALLY, THE ROUTINE CREATES A ROTATION MATRIX AND THEN
139	* MULTIPLIES IT WITH THE ARGUMENT MATRIX. THE ROTATION IS SPECIFIED
140	* COUNTERCLOCKWISE FORWARD, ANGLE IN RADIANT.
141	* THE ANGLE ARGUMENT IS A SINGLE PRECISION FLOATING POINT NUMER
142	* TAKING TWO WORDS TO STORE.
143	*
144	* JST M$ROT
145	* DAC MATRIX MATRIX TO MODIFY
146	* DAC ANGLE RADIANT ANGLE
147	*
148	*
149	* M$SCLE: SCALE MATRIX
150	*
151	* THIS ROUTINE WORKS SIMILAR TO M$ROT BUT SCALES THE ARGUMENT MATRIX.
152	* THE SCALE FACTOR IS A FLOATING POINT NUMBER. LIKE THE ROTATION ANGLE.
153	*
154	* JST M$SCLE
155	* DAC MATRIX MATRIX TO MODIFY
156	* DAC SCALE SCALE FACTOR
157	*
158	*
8fac3a64	159	********************************************************************************
8fac3a64	160	*
13f9c770	161	**** EXPORTED SYMBOLS
	162	*
	163	SUBR MATRIX,INIT JUST A FANCY LABEL
	164	SUBR M$INIT,INIT INITIALISE MATRIX
8fac3a64	165	SUBR M$MUL,MUL MATRIX MULTIPLICATION
	166	SUBR M$APLI,APLI APPLY MATRIX TO INTEGER VECTOR
	167	SUBR M$APII,APII APPLY MATRIX TO PAIR OF INTEGERS
13f9c770	168	SUBR M$ROT,ROT ADD ROTATION TO MATRIX
8fac3a64	169	SUBR M$SCLE,SCLE SCALE MATRIX
8fac3a64	170	*
13f9c770	171	SUBR A$INIT,AFIN INITIALISE AFFINE TRANSFORMATION
	172	*
	173	*
	174	********************************************************************************
	175	*
	176	*
	177	REL RELOCATEABLE MODE
	178	*
	179	*
8fac3a64	180	********************************************************************************
8fac3a64	181	*
13f9c770	182	*
	183	**** INITIALIZE AFFINE TRANSFORMATION
	184	*
	185	AFIN DAC **
	186	LDA* AFIN
	187	STA AFI1 STORE ARGUMENT POINTER
	188	LDX AFIN LOAD INTO INDEX REGISTER, TOO
	189	IRS AFIN TALLY RETURN ADDRESS
	190	*
	191	JST INIT MATRIX INIT
	192	AFI1 DAC **
	193	*
	194	CRA
	195	STA 8,1 CLEAR FIRST VECTOR ELEMENT
	196	STA 9,1 CLEAR SECOND VECTOR ELEMENT
	197	*
	198	JMP* AFIN RETURN TO CALLER
	199	*
	200	*
	201	********************************************************************************
	202	*
8fac3a64	203	*
13f9c770	204	**** INITIALIZE MATRIX
	205	*
	206	* THIS ROUTINE SHOULD BE IMPROVED BY SUPPLYING
	207	* A FLOATING POINT 1.0 CONSTANT!
	208	*
	209	****************************************
	210	*
8fac3a64	211	INIT DAC **
13f9c770	212	LDX* INIT LOAD INDEX REGISTER WITH ADDRESS OF MATRIX
	213	LDA* INIT LOAD MATRIX ADDRESS
	214	STA IM11 STORE POINTER TO FIRST ELEMENT (A11)
	215	ADD =6 IM12,IM21 ARE NOT TO BE INITIALISED WITH FP DATA
	216	STA IM22 STORE POINTER TO FOURTH ELEMENT (A22)
	217	IRS INIT CORRECT RETURN ADDRESS
	218	*
	219	CRA INITIALISE
	220	STA 2,1 A12
	221	STA 3,1
	222	STA 4,1 A21
	223	STA 5,1
	224	CALL FLOAT GENERATE FLOATING POINT 1.0
	225	DAC ONE CONSTANT INTEGER 1
	226	CALL H$22 STORE FLOATING POINT
8fac3a64	227	IM11 DEC 0
	228	CALL H$22
	229	IM22 DEC 0
	230	*
13f9c770	231	JMP* INIT RETURN.
	232	*
	233	*
8fac3a64	234	********************************************************************************
13f9c770	235	*
	236	*
	237	**** MATRIX MULTIPLICATION
	238	*
	239	* C = A * B
	240	*
	241	* \| a11 a12 \| \| b11 b12 \|
	242	* = \| \| * \| \|
	243	* \| a21 a22 \| \| b21 b22 \|
	244	*
	245	* \| (a11b11) (a21b12) \|
	246	* = \| \|
	247	* \| (a12b21) (a22b22) \|
	248	*
	249	* CALL:
	250	* JST MUL
	251	* DAC MC
	252	* DAC MA
	253	* DAC MB
8fac3a64	254	*
13f9c770	255	****************************************
13f9c770	256	*
8fac3a64	257	MUL DAC **
	258	LDX* MUL
	259	*
	260	LDA* MUL
	261	STA PC11
	262	ADD =2
	263	STA PC12
	264	ADD =2
	265	STA PC21
	266	ADD =2
	267	STA PC22
	268	IRS MUL
	269	*
	270	LDA* MUL
	271	STA PA11
	272	ADD =2
	273	STA PA12
	274	ADD =2
	275	STA PA21
	276	ADD =2
	277	STA PA22
	278	ADD =2
	279	*
	280	IRS MUL
	281	*
	282	LDA* MUL
	283	STA PB11
	284	ADD =2
	285	STA PB12
	286	ADD =2
	287	STA PB21
	288	ADD =2
	289	STA PB22
	290	ADD =2
	291	*
	292	IRS MUL
	293	IRS MUL
	294	*
8fac3a64	295	* a11 a12 b11 b12 a11b11 a21b12
	296	* a21 a22 b21 b22 a12b21 a22b22
	297	*
	298	CALL L$22 LOAD REAL
	299	PA11 DAC 0
	300	CALL M$22 MULTIPLY
	301	PB11 DAC 0
	302	CALL H$22 STORE
	303	PC11 DEC 0
	304	*
	305	CALL L$22
	306	PA21 DEC 0
	307	CALL M$22
	308	PB12 DEC 0
	309	CALL H$22
	310	PC12 DEC 0
	311	*
	312	CALL L$22
	313	PA12 DEC 0
	314	CALL M$22
	315	PB21 DEC 0
	316	CALL H$22
	317	PC21 DEC 0
	318	*
	319	CALL L$22
	320	PA22 DEC 0
	321	CALL M$22
	322	PB22 DEC 0
	323	CALL H$22
	324	PC22 DEC 0
	325	*
	326	*
13f9c770	327	JMP* MUL RETURN.
8fac3a64	328	*
13f9c770	329	*
8fac3a64	330	********************************************************************************
	331	*
	332	*
13f9c770	333	**** SCALE MATRIX
13f9c770	334	*
8fac3a64	335	SCLE DAC ** SCALE MATRIX
	336	LDX* SCLE
	337	*
	338	LDA* SCLE GET MATRIX BASE ADDRESS
	339	STA SM11
	340	STA TM11
	341	ADD =6
	342	STA SM22
	343	STA TM22
	344	IRS SCLE
	345	LDA* SCLE
	346	STA SX
	347	STA SY
	348	IRS SCLE TALLY RETURN ADDRESS
	349	*
	350	CALL L$22
	351	SM11 DAC 0
	352	CALL M$22
	353	SX DAC 0
	354	CALL H$22
	355	TM11 DAC 0
	356	*
	357	CALL L$22
	358	SM22 DAC 0
	359	CALL M$22
	360	SY DAC 0
	361	CALL H$22
	362	TM22 DAC 0
	363	*
	364	JMP* SCLE
	365	*
	366	*
13f9c770	367	********************************************************************************
	368	*
	369	*
990b21a1	370	**** ADD ROTATION TO MATRIX
	371	*
	372	*
	373	* M = M * MROT
	374	*
	375	* \| M11 M12 \| \| COS(X) -SIN(X)\|
	376	* = \| \| * \| \|
	377	* \| M21 M22 \| \| SIN( X) COS(X)\|
13f9c770	378	*
990b21a1	379	* \| M11COS(X)+M12SIN(X) M12COS(X)-M11SIN(X) \|
	380	* = \| \|
	381	* \| M21COS(X)+M22SIN(X) M22COS(X)-M21SIN(X) \|
	382	*
	383	* CALL:
	384	* JST ROT
	385	* DAC MATRIX
	386	* DAC ANGLE
	387	* DAC 0 DON'T FORGET!
13f9c770	388	*
	389	****************************************
	390	*
	391	ROT DAC ** ENTRY
990b21a1	392	*
	393	LDA* ROT GET MATRIX POINTER
	394	STA R111 M11, FIRST COPY
	395	STA R211 M11, SECOND COPY
	396	ADD =2
	397	STA R112
	398	STA R212
	399	ADD =2
	400	STA R121
	401	STA R221
	402	ADD =2
	403	STA R122
	404	STA R222
	405	IRS ROT
	406	STA RA1
	407	STA RA2
	408	IRS ROT
	409	IRS ROT
	410	*
	411	*
	412	CALL SINX1 FLOATING POINT SINE
	413	RA1 DAC ** POINTER TO ANGLE
	414	LDA ='77
	415	HLT
	416	CALL H$22 SAVE TO TMP1
	417	DAC TMP1
	418	CALL M$22 MULTIPLY
	419	R112 DAC ** M12
	420	CALL H$22 STORE TO TMP3
	421	DAC TMP3
	422	CALL COSX1 FLOATING POINT COSINE
	423	RA2 DAC ** POINTER TO ANGLE
	424	CALL H$22 SAVE TO TMP2
	425	DAC TMP2
	426	CALL M$22 MULTIPLY
	427	R111 DAC ** M11
	428	CALL A$22 ADD TMP3
	429	DAC TMP3
	430	CALL H$22 SAVE NEW M11 TO TMP3
	431	DAC TMP3
	432	*
	433	CALL L$22 LOAD SINE
	434	DAC TMP1
	435	CALL M$22 MULTIPLY
	436	R212 DAC ** M12
	437	CALL H$22 STORE TO TMP4
	438	DAC TMP4
	439	CALL L$22 LOAD COSINE
	440	CALL M$22 MULTIPLY
	441	R211 DAC **
	442	CALL S$22 SUBSTRACT
	443	DAC TMP4
	444	CALL H$22 SAVE TO NEW M12
	445	R312 DAC **
	446	CALL L$22 LOAD NEW M11 FROM TMP3
	447	CALL H$22 AND SAVE TO NEW M11
	448	R311 DAC **
13f9c770	449	*
13f9c770	450	*
990b21a1	451	CALL L$22 LOAD SINE
	452	CALL M$22 MULTIPLY
	453	R122 DAC ** M12
	454	CALL H$22 STORE TO TMP3
	455	DAC TMP3
	456	CALL H$22 LOAD COSINE
	457	DAC TMP2
	458	CALL M$22 MULTIPLY
	459	R121 DAC ** M11
	460	CALL A$22 ADD TMP3
	461	DAC TMP3
	462	CALL H$22 SAVE NEW M11 TO TMP3
	463	DAC TMP3
	464	*
	465	CALL L$22 LOAD SINE
	466	DAC TMP1
	467	CALL M$22 MULTIPLY
	468	R222 DAC ** M12
	469	CALL H$22 STORE TO TMP4
	470	DAC TMP4
	471	CALL L$22 LOAD COSINE
	472	CALL M$22 MULTIPLY
	473	R221 DAC **
	474	CALL S$22 SUBSTRACT
	475	DAC TMP4
	476	CALL H$22 SAVE TO NEW M12
	477	R322 DAC **
	478	CALL L$22 LOAD NEW M11 FROM TMP3
	479	CALL H$22 AND SAVE TO NEW M11
	480	R321 DAC **
	481	*
	482	*
	483	JMP* ROT RETURN.
	484	*
	485	*
8fac3a64	486	********************************************************************************
	487	*
	488	*
13f9c770	489	**** APPLY MATRIX TO PAIR OF INTEGERS
8fac3a64	490	*
13f9c770	491	* SETS UP MATRIX POINTERS AND VECTOR POINTERS.
	492	* THEN IT CALLS APL, THE REAL WORKING ROUTINE.
	493	*
	494	* CALL:
	495	* JST M$APII
	496	* DAC MATRIX
	497	* DAC X
	498	* DAC Y
	499	* DAC 0 DON'T FORGET!
	500	*
	501	****************************************
8fac3a64	502	*
	503	APII DAC **
	504	*
	505	LDA* APII
	506	STA MP11
	507	ADD =2
	508	STA MP12
	509	ADD =2
	510	STA MP21
	511	ADD =2
	512	STA MP22
	513	IRS APII
	514	*
	515	LDA* APII
	516	STA XP1
	517	STA XP2
	518	IRS APII
	519	LDA* APII
	520	STA YP1
	521	STA YP2
	522	IRS APII
	523	IRS APII
	524	JST APL CALL REAL ROUTINE
	525	JMP* APII
	526	*
	527	********************************************************************************
	528	*
	529	*
13f9c770	530	**** APPLY MATRIX TO VECTOR
	531	*
	532	* SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
	533	* THE REAL WORKING ROUTINE.
8fac3a64	534	*
13f9c770	535	* CALL:
	536	* JST M$APLI
	537	* DAC MATRIX
	538	* DAC VECTOR
	539	* DAC 0 DON'T FORGET!
	540	*
	541	****************************************
8fac3a64	542	*
8fac3a64	543	APLI DAC **
13f9c770	544	*
8fac3a64	545	LDA* APLI
	546	STA MP11
	547	ADD =2
	548	STA MP12
	549	ADD =2
	550	STA MP21
	551	ADD =2
	552	STA MP22
	553	IRS APLI
	554	*
	555	LDA* APLI
	556	STA XP1
	557	STA XP2
	558	AOA
	559	STA YP1
	560	STA YP2
	561	IRS APLI
	562	IRS APLI
13f9c770	563	JST APL CALL INTERNAL ROUTINE
13f9c770	564	JMP* APLI RETURN.
8fac3a64	565	*
8fac3a64	566	*
13f9c770	567	********************************************************************************
8fac3a64	568	*
8fac3a64	569	*
13f9c770	570	**** INTERNAL ROUTINE OF M$APL AND M$APII.
	571	*
	572	* ALL DATA IS SET UP BY THE BOTH USER ROUTINES ABOVE.
	573	*
	574	****************************************
	575	*
	576	APL DAC **
8fac3a64	577	*
	578	CALL FLOAT LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER
	579	XP1 DAC 0
	580	CALL M$22 MULTIPLY FLOAT*FLOAT
	581	MP11 DAC 0
	582	CALL H$22 STORE FLOAT
990b21a1	583	DAC TMP1
8fac3a64	584	CALL FLOAT
	585	YP1 DAC 0
	586	CALL M$22
	587	MP12 DAC 0
	588	CALL A$22
990b21a1	589	DAC TMP1
8fac3a64	590	JST RND ROUND AND CONVERT TO INTEGER
	591	STA PA21 STORE NEW X VALUE INTO TEMPORARY LOCATION
	592	****
	593	CALL FLOAT
	594	XP2 DAC 0
	595	CALL M$22
	596	MP21 DAC 0
	597	CALL H$22
990b21a1	598	DAC TMP1
8fac3a64	599	*
	600	CALL FLOAT
	601	YP2 DAC 0
	602	CALL M$22
	603	MP22 DAC 0
	604	CALL A$22
990b21a1	605	DAC TMP1
8fac3a64	606	JST RND NOW INTEGER IN AC
	607	STA* YP1 STORE NEW Y VALUE
	608	*
	609	LDA PA21
	610	STA* XP1
	611	JMP* APL RETURN TO CALLER.
	612	*
13f9c770	613	*
13f9c770	614	********************************************************************************
8fac3a64	615	*
13f9c770	616	*
	617	**** ROUND FLOAT TO INTEGER ROUTINE
	618	*
	619	* THERE IS NO CORRECTLY WORKING ROUNDING ROUTINE IN THE LIBRARY.
	620	* SO THIS IS A WORKAROUND. ADDS 0.5 TO THE VALUE AND USES ONE
	621	* ONE OF THE TRUNCATE AND CONVERT ROUTINES.
	622	* THE ARGUMENT IS IN REGISTERS A/B, THE RESULT IS PUT INTO A.
	623	*
	624	****************************************
	625	*
	626	RND DAC **
	627	CALL A$22 ADD
	628	DAC HLF 0.5
	629	CALL C$21 TRUNCATE TO INTEGER
8fac3a64	630	NOP
8fac3a64	631	JMP* RND
13f9c770	632	*
	633	*
	634	********************************************************************************
	635	*
	636	*
	637	**** CONSTANTS
	638	*
	639	ONE DEC 1
8fac3a64	640	HLF OCT '040100 CONSTANT 0.5
8fac3a64	641	OCT '000000
13f9c770	642	*
13f9c770	643	*
8fac3a64	644	********************************************************************************
13f9c770	645	*
	646	**** VARIABLES
	647	*
990b21a1	648	TMP1 BSS '2 TEMPORARY 2-WORD VARIABLE
	649	TMP2 BSS '2 " " "
	650	TMP3 BSS '2 " " "
	651	TMP4 BSS '2 " " "
8fac3a64	652	*
	653	*
	654	********************************************************************************
	655	*
13f9c770	656	*
	657	**** END OF THE LINE
	658	*
8fac3a64	659	END
8fac3a64	660	*
13f9c770	661	*
8fac3a64	662	********************************************************************************