-*
-*
-*
-* MATRIX FORMAT:
-*
-* a11 a12
-*
-* a21 a22
-*
-* a11-a22 are single precision float variables (2 word).
-*
-*
-* IN MEMORY LAYOUT:
-*
-* a11
-* a11
-* a12
-* a12
-* a21
-* a21
-* a22
-* a22
-*
-*
-* JST M$INIT INITIALIZE MATRIX TO IDENTITY
-* DAC MATRIX ADDRESS
-*
-*
+* 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
+* 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
+*
+*
********************************************************************************
*
- SUBR M$INIT,INIT INITIALIZE MATRIX
+**** 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,XXX ADD ROTATION TO MATRIX ARGUMENT
+ SUBR M$ROT,ROT ADD ROTATION TO MATRIX
SUBR M$SCLE,SCLE SCALE MATRIX
*
- REL
- ORG '0
-*
-*
-*
-*
-*
+ 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
-*
- LDA* INIT GET MATRIX BASE ADDRESS
- STA IM11
- ADD =6
- STA IM22
- IRS INIT
-*
- CRA
- STA 2,1
- STA 3,1
- STA 4,1
- STA 5,1
- CALL FLOAT
- DAC ONE
- CALL H$22
+ 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
-ONE DEC 1
-*
-*
+ 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
*
-* C=A*B
-*
-* a11 a12 b11 b12 a11*b11 a21*b12
-* a21 a22 b21 b22 a12*b21 a22*b22
-*
-* JST MUL
-* DAC MC
-* DAC MA
-* DAC MB
-*
+****************************************
+*
MUL DAC **
LDX* MUL
*
IRS MUL
IRS MUL
*
-*
* a11 a12 b11 b12 a11*b11 a21*b12
* a21 a22 b21 b22 a12*b21 a22*b22
*
PC22 DEC 0
*
*
- JMP* MUL
+ JMP* MUL RETURN.
*
+*
********************************************************************************
*
*
+**** SCALE MATRIX
+*
SCLE DAC ** SCALE MATRIX
LDX* SCLE
*
STA SX
STA SY
IRS SCLE TALLY RETURN ADDRESS
+ IRS SCLE AGAIN
*
CALL L$22
SM11 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
+ 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 Pair of integers and round
+**** APPLY MATRIX TO PAIR OF INTEGERS
*
-* JST M$APII
-* DAC MATRIX
-* DAC X
-* DAC Y
-* DAC 0
+* 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
+ 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 XP1 STORE TO X-POINTER
+ STA XP2 STORE TO X-POINTER
+ IRS APII JUMP TO NEXT ARGUMENT (Y)
+ LDA* APII LOAD Y VALUE
+ STA YP1 STORE TO Y-POINTER
+ STA YP2 STORE TO Y-POINTER
+ IRS APII CORRECT RETURN ADDRESS
+ IRS APII FOR FORTRANIV COMPATIBILITY
JST APL CALL REAL ROUTINE
JMP* APII
*
********************************************************************************
*
*
-* Apply to integer vector and round
+**** APPLY MATRIX TO VECTOR
+*
+* SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
+* THE REAL WORKING ROUTINE.
*
-* JST M$APLI
-* DAC MATRIX
-* DAC X Y MUST FOLLOW IN NEXT LOCATION!
+* CALL:
+* JST M$APLI
+* DAC MATRIX
+* DAC VECTOR
+* DAC 0 DON'T FORGET!
+*
+****************************************
*
APLI DAC **
-*
+*
LDA* APLI
STA MP11
ADD =2
STA YP2
IRS APLI
IRS APLI
- JST APL
- JMP* APLI
+ JST APL CALL INTERNAL ROUTINE
+ JMP* APLI RETURN.
*
*
-****************************************
+********************************************************************************
*
*
-APL DAC ** REAL APPLY ROUTINE
+**** 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 TMP
+ DAC TMP1
CALL FLOAT
YP1 DAC 0
CALL M$22
MP12 DAC 0
CALL A$22
- DAC TMP
+ DAC TMP1
JST RND ROUND AND CONVERT TO INTEGER
STA PA21 STORE NEW X VALUE INTO TEMPORARY LOCATION
****
CALL M$22
MP21 DAC 0
CALL H$22
- DAC TMP
+ DAC TMP1
*
CALL FLOAT
YP2 DAC 0
CALL M$22
MP22 DAC 0
CALL A$22
- DAC TMP
+ DAC TMP1
JST RND NOW INTEGER IN AC
STA* YP1 STORE NEW Y VALUE
*
STA* XP1
JMP* APL RETURN TO CALLER.
*
-****************************************
+*
+********************************************************************************
*
-RND DAC ** ROUND A/B AND RETURN WITH INTEGER IN A
- CALL A$22 ADD 0.5
- DAC HLF
- CALL C$21 CONVERT TO INTEGER
+*
+**** 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
-*
-****************************************
-*
-TMP BSS 2
-*
-*
+*
+*
********************************************************************************
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
-*
+*
+**** VARIABLES
+*
+TMP1 BSS '2 TEMPORARY 2-WORD VARIABLE
+TMP2 BSS '2 " " "
+TMP3 BSS '2 " " "
+TMP4 BSS '2 " " "
*
*
********************************************************************************
*
+*
+**** END OF THE LINE
+*
END
*
+*
********************************************************************************
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
projects / h316.git / blobdiff