X-Git-Url: http://gitweb.hachti.de/?a=blobdiff_plain;f=lib%2Fhachti%2Fsrc%2Fmatrix.asm;h=812fd23adcc4bfa378baa701728f35ee92f9b496;hb=8eb8811723f247b223acf77c00171318fb1db645;hp=2bd09c61fd5a604056852cc6bc56157853a70642;hpb=8fac3a64e23edb8f2cd4cdc28631d603075de709;p=h316.git diff --git a/lib/hachti/src/matrix.asm b/lib/hachti/src/matrix.asm index 2bd09c6..812fd23 100644 --- a/lib/hachti/src/matrix.asm +++ b/lib/hachti/src/matrix.asm @@ -1,87 +1,260 @@ -* -* -* -* 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 * @@ -120,7 +293,6 @@ MUL DAC ** IRS MUL IRS MUL * -* * a11 a12 b11 b12 a11*b11 a21*b12 * a21 a22 b21 b22 a12*b21 a22*b22 * @@ -153,11 +325,14 @@ PB22 DEC 0 PC22 DEC 0 * * - JMP* MUL + JMP* MUL RETURN. * +* ******************************************************************************** * * +**** SCALE MATRIX +* SCLE DAC ** SCALE MATRIX LDX* SCLE * @@ -172,6 +347,7 @@ SCLE DAC ** SCALE MATRIX STA SX STA SY IRS SCLE TALLY RETURN ADDRESS + IRS SCLE AGAIN * CALL L$22 SM11 DAC 0 @@ -190,54 +366,227 @@ 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 + 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 @@ -256,27 +605,33 @@ APLI DAC ** 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 **** @@ -285,14 +640,14 @@ XP2 DAC 0 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 * @@ -300,218 +655,53 @@ MP22 DAC 0 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