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 **** 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)|
 378 *
 379 *        | M11*COS(X)+M12*SIN(X)  M12*COS(X)-M11*SIN(X) |
 380 *      = |                                              |
 381 *        | M21*COS(X)+M22*SIN(X)  M22*COS(X)-M21*SIN(X) |
 382 *
 383 * CALL:
 384 *       JST     ROT
 385 *       DAC     MATRIX
 386 *       DAC     ANGLE
 387 *       DAC     0       DON'T FORGET!
 388 *
 389 ****************************************
 390 *
 391 ROT     DAC     **      ENTRY
 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     **
 449 *
 450 *
 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 *
 486 ********************************************************************************
 487 *
 488 *
 489 **** APPLY MATRIX TO PAIR OF INTEGERS
 490 *
 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 ****************************************
 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 *
 530 **** APPLY MATRIX TO VECTOR
 531 *
 532 * SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
 533 * THE REAL WORKING ROUTINE.
 534 *
 535 * CALL:
 536 *       JST     M$APLI
 537 *       DAC     MATRIX
 538 *       DAC     VECTOR
 539 *       DAC     0       DON'T FORGET!
 540 *
 541 ****************************************
 542 *
 543 APLI    DAC     **
 544 *
 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
 563         JST     APL     CALL INTERNAL ROUTINE
 564         JMP*    APLI    RETURN.
 565 *
 566 *
 567 ********************************************************************************
 568 *
 569 *
 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     **
 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
 583         DAC     TMP1
 584         CALL    FLOAT
 585 YP1     DAC     0
 586         CALL    M$22
 587 MP12    DAC     0
 588         CALL    A$22
 589         DAC     TMP1
 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
 598         DAC     TMP1
 599 *
 600         CALL    FLOAT
 601 YP2     DAC     0
 602         CALL    M$22
 603 MP22    DAC     0
 604         CALL    A$22
 605         DAC     TMP1
 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 *
 613 *
 614 ********************************************************************************
 615 *
 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
 630         NOP
 631         JMP*    RND
 632 *
 633 *
 634 ********************************************************************************
 635 *
 636 *
 637 **** CONSTANTS
 638 *
 639 ONE     DEC     1
 640 HLF     OCT     '040100 CONSTANT 0.5
 641         OCT     '000000
 642 *
 643 *
 644 ********************************************************************************
 645 *
 646 **** VARIABLES
 647 *
 648 TMP1    BSS     '2      TEMPORARY 2-WORD VARIABLE
 649 TMP2    BSS     '2            "      "      "
 650 TMP3    BSS     '2            "      "      "
 651 TMP4    BSS     '2            "      "      "
 652 *
 653 *
 654 ********************************************************************************
 655 *
 656 *
 657 **** END OF THE LINE
 658 *
 659         END
 660 *
 661 *
 662 ********************************************************************************