lib/hachti/src/matrix.asm

   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 *       | VI1*A11 + VI2*A12 + VT1 |
  54 *    =  |                         |
  55 *       | VI1*A21 + VI2*A22 + 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 *
 159 ********************************************************************************
 160 *
 161 **** EXPORTED SYMBOLS
 162 *
 163         SUBR    MATRIX,INIT     JUST A FANCY LABEL
 164         SUBR    M$INIT,INIT     INITIALISE MATRIX
 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
 168         SUBR    M$ROT,ROT       ADD ROTATION TO MATRIX
 169         SUBR    M$SCLE,SCLE     SCALE MATRIX
 170 *
 171         SUBR    A$INIT,AFIN     INITIALISE AFFINE TRANSFORMATION
 172 *
 173 *
 174 ********************************************************************************
 175 *
 176 *
 177         REL                     RELOCATEABLE MODE
 178 *
 179 *
 180 ********************************************************************************
 181 *
 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 *
 203 *
 204 **** INITIALIZE MATRIX
 205 *
 206 *       THIS ROUTINE SHOULD BE IMPROVED BY SUPPLYING
 207 *       A FLOATING POINT 1.0 CONSTANT!
 208 *
 209 ****************************************
 210 *
 211 INIT    DAC     **
 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
 227 IM11    DEC     0
 228         CALL    H$22
 229 IM22    DEC     0
 230 *
 231         JMP*    INIT    RETURN.
 232 *
 233 *
 234 ********************************************************************************
 235 *
 236 *
 237 **** MATRIX MULTIPLICATION
 238 *
 239 *     C =      A      *      B
 240 *
 241 *         | a11 a12 |   | b11 b12 |
 242 *       = |         | * |         |
 243 *         | a21 a22 |   | b21 b22 |
 244 *
 245 *         | (a11*b11) (a21*b12) |
 246 *       = |                     |
 247 *         | (a12*b21) (a22*b22) |
 248 *
 249 * CALL:
 250 *       JST MUL
 251 *       DAC MC
 252 *       DAC MA
 253 *       DAC MB
 254 *
 255 ****************************************
 256 *
 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 *
 295 *  a11 a12  b11 b12   a11*b11 a21*b12
 296 *  a21 a22  b21 b22   a12*b21 a22*b22
 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 *
 327         JMP*    MUL     RETURN.
 328 *
 329 *
 330 ********************************************************************************
 331 *
 332 *
 333 **** SCALE MATRIX
 334 *
 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 *
 367 ********************************************************************************
 368 *
 369 *
 370 **** ROTATE MATRIX
 371 *
 372 *       THIS ROUTINE IS NOT YET FINISHED!
 373 *
 374 ****************************************
 375 *
 376 ROT     DAC     **      ENTRY
 377         IRS     ROT     TALLY RETURN ADDRESS
 378         JMP*    ROT     EXIT
 379 *
 380 *
 381 ********************************************************************************
 382 *
 383 *
 384 **** APPLY MATRIX TO PAIR OF INTEGERS
 385 *
 386 *       SETS UP MATRIX POINTERS AND VECTOR POINTERS.
 387 *       THEN IT CALLS APL, THE REAL WORKING ROUTINE.
 388 *
 389 * CALL:
 390 *       JST     M$APII
 391 *       DAC     MATRIX
 392 *       DAC     X
 393 *       DAC     Y
 394 *       DAC     0       DON'T FORGET!
 395 *
 396 ****************************************
 397 *
 398 APII    DAC     **
 399 *
 400         LDA*    APII
 401         STA     MP11
 402         ADD     =2
 403         STA     MP12
 404         ADD     =2
 405         STA     MP21
 406         ADD     =2
 407         STA     MP22
 408         IRS     APII
 409 *
 410         LDA*    APII
 411         STA     XP1
 412         STA     XP2
 413         IRS     APII
 414         LDA*    APII
 415         STA     YP1
 416         STA     YP2
 417         IRS     APII
 418         IRS     APII
 419         JST     APL     CALL REAL ROUTINE
 420         JMP*    APII
 421 *
 422 ********************************************************************************
 423 *
 424 *
 425 **** APPLY MATRIX TO VECTOR
 426 *
 427 * SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
 428 * THE REAL WORKING ROUTINE.
 429 *
 430 * CALL:
 431 *       JST     M$APLI
 432 *       DAC     MATRIX
 433 *       DAC     VECTOR
 434 *       DAC     0       DON'T FORGET!
 435 *
 436 ****************************************
 437 *
 438 APLI    DAC     **
 439 *
 440         LDA*    APLI
 441         STA     MP11
 442         ADD     =2
 443         STA     MP12
 444         ADD     =2
 445         STA     MP21
 446         ADD     =2
 447         STA     MP22
 448         IRS     APLI
 449 *
 450         LDA*    APLI
 451         STA     XP1
 452         STA     XP2
 453         AOA
 454         STA     YP1
 455         STA     YP2
 456         IRS     APLI
 457         IRS     APLI
 458         JST     APL     CALL INTERNAL ROUTINE
 459         JMP*    APLI    RETURN.
 460 *
 461 *
 462 ********************************************************************************
 463 *
 464 *
 465 **** INTERNAL ROUTINE OF M$APL AND M$APII.
 466 *
 467 * ALL DATA IS SET UP BY THE BOTH USER ROUTINES ABOVE.
 468 *
 469 ****************************************
 470 *
 471 APL     DAC     **
 472 *
 473         CALL    FLOAT   LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER
 474 XP1     DAC     0
 475         CALL    M$22    MULTIPLY FLOAT*FLOAT
 476 MP11    DAC     0
 477         CALL    H$22    STORE FLOAT
 478         DAC     TMP
 479         CALL    FLOAT
 480 YP1     DAC     0
 481         CALL    M$22
 482 MP12    DAC     0
 483         CALL    A$22
 484         DAC     TMP
 485         JST     RND     ROUND AND CONVERT TO INTEGER
 486         STA     PA21    STORE NEW X VALUE INTO TEMPORARY LOCATION
 487 ****
 488         CALL    FLOAT
 489 XP2     DAC     0
 490         CALL    M$22
 491 MP21    DAC     0
 492         CALL    H$22
 493         DAC     TMP
 494 *
 495         CALL    FLOAT
 496 YP2     DAC     0
 497         CALL    M$22
 498 MP22    DAC     0
 499         CALL    A$22
 500         DAC     TMP
 501         JST     RND     NOW INTEGER IN AC
 502         STA*    YP1     STORE NEW Y VALUE
 503 *
 504         LDA     PA21
 505         STA*    XP1
 506         JMP*    APL     RETURN TO CALLER.
 507 *
 508 *
 509 ********************************************************************************
 510 *
 511 *
 512 **** ROUND FLOAT TO INTEGER ROUTINE
 513 *
 514 * THERE IS NO CORRECTLY WORKING ROUNDING ROUTINE IN THE LIBRARY.
 515 * SO THIS IS A WORKAROUND. ADDS 0.5 TO THE VALUE AND USES ONE
 516 * ONE OF THE TRUNCATE AND CONVERT ROUTINES.
 517 * THE ARGUMENT IS IN REGISTERS A/B, THE RESULT IS PUT INTO A.
 518 *
 519 ****************************************
 520 *
 521 RND     DAC     **
 522         CALL    A$22    ADD
 523         DAC     HLF         0.5
 524         CALL    C$21    TRUNCATE TO INTEGER
 525         NOP
 526         JMP*    RND
 527 *
 528 *
 529 ********************************************************************************
 530 *
 531 *
 532 **** CONSTANTS
 533 *
 534 ONE     DEC     1
 535 HLF     OCT     '040100 CONSTANT 0.5
 536         OCT     '000000
 537 *
 538 *
 539 ********************************************************************************
 540 *
 541 **** VARIABLES
 542 *
 543 TMP     BSS     '10     SOME SPACE
 544 *
 545 *
 546 ********************************************************************************
 547 *
 548 *
 549 **** END OF THE LINE
 550 *
 551         END
 552 *
 553 *
 554 ********************************************************************************