X-Git-Url: http://gitweb.hachti.de/?a=blobdiff_plain;f=lib%2Fhachti%2Fsrc%2Fmatrix.asm;h=79202db70cfda21765c874647f29d132b434d348;hb=c0fc7e111cb540730e471bc795309f65cf32a512;hp=2bd09c61fd5a604056852cc6bc56157853a70642;hpb=8fac3a64e23edb8f2cd4cdc28631d603075de709;p=h316.git diff --git a/lib/hachti/src/matrix.asm b/lib/hachti/src/matrix.asm index 2bd09c6..79202db 100644 --- a/lib/hachti/src/matrix.asm +++ b/lib/hachti/src/matrix.asm @@ -1,87 +1,502 @@ -* -* -* -* 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 | +* +* 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 +* +* +* ******************************************************************************** * - 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$ROTI,ROTI ADD ROTATION TO MATRIX SUBR M$SCLE,SCLE SCALE MATRIX -* - REL - ORG '0 -* -* -* -* -* + 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 -* - LDA* INIT GET MATRIX BASE ADDRESS - STA IM11 - ADD =6 - STA IM22 - IRS INIT -* - CRA - STA 2,1 - STA 3,1 - STA 4,1 + 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 - CALL FLOAT - DAC ONE - CALL H$22 -IM11 DEC 0 - CALL H$22 -IM22 DEC 0 -* - JMP* INIT -ONE DEC 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 * -* 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 * @@ -120,7 +535,6 @@ MUL DAC ** IRS MUL IRS MUL * -* * a11 a12 b11 b12 a11*b11 a21*b12 * a21 a22 b21 b22 a12*b21 a22*b22 * @@ -153,91 +567,304 @@ PB22 DEC 0 PC22 DEC 0 * * - JMP* MUL + JMP* MUL RETURN. * +* ******************************************************************************** * * +**** SCALE MATRIX +* SCLE DAC ** SCALE MATRIX - LDX* SCLE * LDA* SCLE GET MATRIX BASE ADDRESS STA SM11 STA TM11 - ADD =6 + ADD =2 + STA SM12 + STA TM12 + ADD =2 + STA SM21 + STA TM21 + ADD =2 STA SM22 STA TM22 IRS SCLE LDA* SCLE - STA SX - STA SY + STA S1 + STA S2 + STA S3 + STA S4 IRS SCLE TALLY RETURN ADDRESS + IRS SCLE AGAIN * CALL L$22 -SM11 DAC 0 +SM11 DAC ** CALL M$22 -SX DAC 0 +S1 DAC ** CALL H$22 -TM11 DAC 0 +TM11 DAC ** * CALL L$22 -SM22 DAC 0 +SM12 DAC ** CALL M$22 -SY DAC 0 +S2 DAC ** CALL H$22 -TM22 DAC 0 +TM12 DAC ** * - JMP* SCLE + 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 Pair of integers and round -* -* JST M$APII -* DAC MATRIX -* DAC X -* DAC Y -* DAC 0 +**** 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 - 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 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 to integer vector and round -* -* JST M$APLI -* DAC MATRIX -* DAC X Y MUST FOLLOW IN NEXT LOCATION! +**** 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 @@ -249,269 +876,208 @@ APLI DAC ** IRS APLI * LDA* APLI - STA XP1 - STA XP2 + STA XOP + AOA + STA YOP + IRS APLI +* + LDA* APLI + STA XIP1 + STA XIP2 AOA - STA YP1 - STA YP2 + STA YIP1 + STA YIP2 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. +* +* USED VARIABLES: TMP1 +* +**************************************** +* +APL DAC ** * CALL FLOAT LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER -XP1 DAC 0 +XIP1 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 +YIP1 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 FLOAT -XP2 DAC 0 +XIP2 DAC 0 CALL M$22 MP21 DAC 0 CALL H$22 - DAC TMP + DAC TMP1 * CALL FLOAT -YP2 DAC 0 +YIP2 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* YOP STORE NEW Y VALUE * LDA PA21 - STA* XP1 + 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 +* +* +******************************************************************************** * -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 +* +* +******************************************************************************** +* +* +**** 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 -* -**************************************** -* -TMP BSS 2 -* -* +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 * +* ******************************************************************************** - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file