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 * WHICH 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 TO THE LOCATION
 116 * DESIGNATED BY THE TARGET ADDRESS. SOURCE AND TARGET MAY BE THE SAME,
 117 * THE SOURCE'S CONTENTS ARE NOT ALTERED.
 118 *
 119 *               JST     M$APLI
 120 *               DAC     MATRIX  MATRIX TO APPLY
 121 *               DAC     TARGET  POINTER TO TARGET VECTOR
 122 *               DAC     SOURCE  VECTOR TO TRANSFORM
 123 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 124 *
 125 *
 126 * M$APII: APPLY MATRIX TO PAIR OF INTEGERS AS VECTOR
 127 *
 128 * THIS ROUTINE USES TWO DISTINCT INTEGER POINTERS TO DESCRIBE A POINT.
 129 * THE REST OF THE BEHAVIOR IS EXACTLY LIKE M$APL.
 130 *
 131 *               JST     M$APII
 132 *               DAC     MATRIX  MATRIX TO APPLY
 133 *               DAC     XO      X COORDINATE OF RESULT VECTOR
 134 *               DAC     XO      Y COORDINATE OF RESULT VECTOR
 135 *               DAC     XI      X COORDINATE OF ARGUMENT VECTOR
 136 *               DAC     YI      Y COORDINATE OF ARGUMENT VECTOR
 137 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 138 *
 139 *
 140 * M$ROT: ROTATE MATRIX
 141 *
 142 * THIS ROUTINE TAKES A MATRIX AND ADDS A ROTATION TO IT.
 143 * INTERNALLY, THE ROUTINE CREATES A ROTATION MATRIX AND THEN
 144 * MULTIPLIES IT WITH THE ARGUMENT MATRIX. THE ROTATION IS SPECIFIED
 145 * COUNTERCLOCKWISE FORWARD, ANGLE IN RADIANT.
 146 * THE ANGLE ARGUMENT IS A SINGLE PRECISION FLOATING POINT NUMER
 147 * TAKING TWO WORDS TO STORE.
 148 *
 149 *               JST     M$ROT
 150 *               DAC     MATRIX  MATRIX TO MODIFY
 151 *               DAC     ANGLE   RADIANT ANGLE
 152 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 153 *
 154 *
 155 * M$ROTI: ROTATE MATRIX
 156 *
 157 * WORKS LIKE M$ROT, BUT TAKES AN INTEGER DEGREE VALUE AS ARGUMENT.
 158 *
 159 *               JST     M$ROTI
 160 *               DAC     MATRIX  MATRIX TO MODIFY
 161 *               DAC     ANGLE   DEGREE ANGLE
 162 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 163 *
 164 *
 165 * M$SCLE: SCALE MATRIX
 166 *
 167 * THIS ROUTINE WORKS SIMILAR TO M$ROT BUT SCALES THE ARGUMENT MATRIX.
 168 * THE SCALE FACTOR IS A FLOATING POINT NUMBER. LIKE THE ROTATION ANGLE.
 169 *
 170 *               JST     M$SCLE
 171 *               DAC     MATRIX  MATRIX TO MODIFY
 172 *               DAC     SCALE   SCALE FACTOR
 173 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 174 *
 175 *
 176 *********************************************************************************
 177 *
 178 *
 179 * T$INIT: INITIALISE AFFINE TRANSFORM
 180 *
 181 *               JST     T$INIT
 182 *               DAC     TRANS   POINTER TO AFFINE TRANSFORMATION (SEE ABOVE)
 183 *
 184 *
 185 * T$SCLE: SCALE AFFINE TRANSFORMATION
 186 *
 187 * THIS SCALES THE MATRIX OF THE AFFINE TRANSFORMATION BY FACTOR SCALE.
 188 * CALLS M$SCLE INTERNALLY.
 189 *
 190 *               JST     T$SCLE
 191 *               DAC     TRANS   TRANSFORMATION TO MODIFY
 192 *               DAC     SCALE   SCALE FACTOR
 193 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 194 *
 195 *
 196 * T$TRAN: ADD RELOCATION TO AFFINE TRANSFORMATION
 197 *
 198 * THE OFFSET VECTOR IS FIRST PROCESSED BY THE TRANSFORMATION.
 199 * THEN IT IS ADDED TO THE TRANSFORMATION'S TRANSLATION VECTOR.
 200 *
 201 *               JST     T$TRAN
 202 *               DAC     TRANS   TRANSFORMATION TO MODIFY
 203 *               DAC     XOFF    X OFFSET
 204 *               DAC     YOFF    Y OFFSET
 205 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 206 *
 207 *
 208 * T$ROT: ADD ROTATION TO AFFINE TRANSFORMATION
 209 *
 210 * ADDS ROTATION TO THE MATRIX OF THE AFFINE TRANSFORMATION.
 211 * CALLS M$$ROT INTERNALLY.
 212 *
 213 *               JST     T$ROT
 214 *               DAC     TRANS   TRANSFORMATION TO MODIFY
 215 *               DAC     ANGLE   ANGLE LIKE FOR M$ROT
 216 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 217 *
 218 *
 219 * T$ROTI: ADD ROTATION TO AFFINE TRANSFORMATION
 220 * USES AN INTEGER ARGUMENT INSTEAD OF FLOATING POINT RADIANT.
 221 *
 222 * ADDS ROTATION TO THE MATRIX OF THE AFFINE TRANSFORMATION.
 223 * CALLS M$$ROTI INTERNALLY.
 224 *
 225 *               JST     T$ROTI
 226 *               DAC     TRANS   TRANSFORMATION TO MODIFY
 227 *               DAC     ANGLE   ANGLE LIKE FOR M$ROTI
 228 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 229 *
 230 *
 231 * T$APII: APPLY AFFINE TRANSFORM TO PAIR OF INTEGERS AS VECTOR
 232 *
 233 * WORKS LIKE M$APII WHICH IS USED INTERNALLY.
 234 *
 235 *               JST     T$APII
 236 *               DAC     TRANS   TRANSFORMATION TO USE
 237 *               DAC     XO      X COORDINATE OF RESULT VECTOR
 238 *               DAC     XO      Y COORDINATE OF RESULT VECTOR
 239 *               DAC     XI      X COORDINATE OF ARGUMENT VECTOR
 240 *               DAC     YI      Y COORDINATE OF ARGUMENT VECTOR
 241 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 242 *
 243 *
 244 * T$APLI: APPLY AFFINE TRANSFORM TO VECTOR
 245 *
 246 * WORKS LIKE M$APL WHICH IS USED INTERNALLY.
 247 *
 248 *               JST     T$APLI
 249 *               DAC     TRANS
 250 *               DAC     TARGET  POINTER TO TARGET VECTOR
 251 *               DAC     SOURCE  POINTER TO INPUT VECTOR
 252 *               DAC     0       FOR FORTRAN IV COMPATIBILITY
 253 *
 254 *
 255 *
 256 ********************************************************************************
 257 *
 258 **** EXPORTED SYMBOLS
 259 *
 260         SUBR    MATRIX,INIT     JUST A FANCY LABEL
 261         SUBR    M$INIT,INIT     INITIALISE MATRIX
 262         SUBR    M$MUL,MUL       MATRIX MULTIPLICATION
 263         SUBR    M$APLI,APLI     APPLY MATRIX TO INTEGER VECTOR
 264         SUBR    M$APII,APII     APPLY MATRIX TO PAIR OF INTEGERS
 265         SUBR    M$ROT,ROT       ADD ROTATION TO MATRIX
 266         SUBR    M$ROTI,ROTI     ADD ROTATION TO MATRIX
 267         SUBR    M$SCLE,SCLE     SCALE MATRIX
 268         SUBR    M$SCLI,SCLI     SCALE MATRIX (INTEGER PERCENT)
 269 *
 270         SUBR    T$INIT,AFIN     INITIALISE AFFINE TRANSFORMATION
 271         SUBR    T$APLI,TPLI     APPLY AFFINE TRANSFORM TO INTEGER VECTOR
 272         SUBR    T$APII,TPII     APPLY AFFINE TRANSFORM TO PAIR OF INTEGERS
 273         SUBR    T$ROT,ROT       ADD ROTATION TO AFFINE TRANSFORMATION
 274         SUBR    T$ROTI,ROTI     ADD ROTATION TO AFFINE TRANSFORMATION
 275         SUBR    T$SCLE,SCLE     SCALE AFFINE TRANSFORMATION
 276         SUBR    T$SCLI,SCLI     SCALE AFFINE TRANSFORMATION (INTEGER PERCENT)
 277         SUBR    T$TRAN,TRAN     ADD TRANSLATION TO AFFINE TRANSFORMATION
 278 *
 279 *
 280 ********************************************************************************
 281 *
 282 *
 283         REL                     RELOCATEABLE MODE
 284 *
 285 *
 286 ********************************************************************************
 287 *
 288 *
 289 *** T$TRAN - TRANSLATE
 290 *
 291 *
 292 *       ABS
 293 *       ORG     '4000
 294 TRAN    DAC     **      ENTRY.
 295         LDA*    TRAN    TRANSFORMATION POINTER
 296         STA     TPT
 297         ADD     =8
 298         STA     VECP
 299         IRS     TRAN
 300 *
 301         LDA*    TRAN    X OFFSET
 302         STA     XOFP
 303         IRS     TRAN
 304 *
 305         LDA*    TRAN    Y OFFSET
 306         STA     YOFP
 307         IRS     TRAN
 308 *
 309         IRS     TRAN    FOR FORTRAN IV
 310 *
 311         JST     APII    FIXME!
 312 TPT     DAC     **
 313         DAC     TMP3    STORE NEW X VALUE IN TMP3
 314         DAC     TMP4    STORE NEW Y VALUE IN TMP4
 315 XOFP    DAC     **
 316 YOFP    DAC     **
 317         DAC     0       FOR FORTRAN IV COMPATIBILITY
 318 *
 319         LDA*    VECP
 320         ADD     TMP3
 321         STA*    VECP
 322         IRS     VECP
 323         LDA*    VECP
 324         ADD     TMP4
 325         STA*    VECP
 326 *
 327         JMP*    TRAN    RETURN.
 328 *
 329 *
 330 ********************************************************************************
 331 *
 332 *
 333 **** T$APLI - APPLY AFFINE TRANSFORMATION TO INTEGER VECTOR
 334 *
 335 * USED VARIABLES: ((TMP1) XOP,YOP,XP1,YP1,XP2,YP2),VECP
 336 *
 337 TPLI    DAC     **      ENTRY.
 338 *
 339         LDA*    TPLI    LOAD POINTER TO TRANSFORMATION
 340         STA     MPT     STORE TO MATRIX POINTER
 341         ADD     =8      FORWARD TO VECTOR ADDRESS IN TRANSFORMATION
 342         STA     VECP    VECTOR ADDRESS
 343         IRS     TPLI
 344 *
 345         LDA*    TPLI    POINTER TO RESULT VECTOR
 346         STA     IOV
 347         IRS     TPLI
 348 *
 349         LDA*    TPLI    POINTER TO INPUT VECTOR
 350         STA     IIV
 351         IRS     TPLI
 352 *
 353         IRS     TPLI
 354 *
 355         JST     APLI    APPLY MATRIX
 356 MPT     DAC     **
 357 IOV     DAC     **
 358 IIV     DAC     **
 359 *
 360         LDA*    IOV     PERFORM VECTOR ADDITION
 361         ADD*    VECP
 362         STA*    IOV
 363         IRS     VECP
 364         IRS     IOV
 365         LDA*    IOV
 366         ADD*    VECP
 367         STA*    IOV
 368 *
 369         JMP*    TPLI
 370 *
 371 *
 372 ********************************************************************************
 373 *
 374 *
 375 **** T$APII - APPLY AFFINE TRANSFORMATION TO PAIR OF INTEGERS
 376 *
 377 * USED VARIABLES: ((TMP1) XOP,YOP,XP1,YP1,XP2,YP2),VECP
 378 *
 379 *
 380 ****************************************
 381 *
 382 TPII    DAC     **      ENTRY.
 383 *
 384         LDA*    TPII    LOAD POINTER TO TRANSFORMATION
 385         STA     IMPT    STORE TO MATRIX POINTER
 386         ADD     =8      FORWARD TO VECTOR ADDRESS IN TRANSFORMATION
 387         STA     VECP    VECTOR ADDRESS
 388         IRS     TPII
 389 *
 390         LDA*    TPII    POINTER TO RESULT X
 391         STA     RXP
 392         IRS     TPII
 393 *
 394         LDA*    TPII    POINTER TO RESULT Y
 395         STA     RYP
 396         IRS     TPII
 397 *
 398         LDA*    TPII    POINTER TO INPUT X
 399         STA     IXP
 400         IRS     TPII
 401 *
 402         LDA*    TPII    POINTER TO INPUT Y
 403         STA     IYP
 404         IRS     TPII
 405 *
 406         IRS     TPII
 407 *
 408         JST     APII    APPLY MATRIX
 409 IMPT    DAC     **
 410 RXP     DAC     **
 411 RYP     DAC     **
 412 IXP     DAC     **
 413 IYP     DAC     **
 414         DAC     0
 415 *
 416         LDA*    VECP    PERFORM THE ADDITION
 417         ADD*    RXP
 418         STA*    RXP
 419         IRS     VECP
 420         LDA*    VECP
 421         ADD*    RYP
 422         STA*    RYP
 423 *
 424         JMP*    TPII    RETURN
 425 *
 426 *
 427 ********************************************************************************
 428 *
 429 *
 430 **** INITIALIZE AFFINE TRANSFORMATION
 431 *
 432 AFIN    DAC     **
 433         LDA*    AFIN
 434         STA     AFI1    STORE ARGUMENT POINTER
 435         LDX     AFIN    LOAD INTO INDEX REGISTER, TOO
 436         IRS     AFIN    TALLY RETURN ADDRESS
 437 *
 438         JST     INIT    MATRIX INIT
 439 AFI1    DAC     **
 440 *
 441         CRA
 442         STA     8,1     CLEAR FIRST VECTOR ELEMENT
 443         STA     9,1     CLEAR SECOND VECTOR ELEMENT
 444 *
 445         JMP*    AFIN    RETURN TO CALLER
 446 *
 447 *
 448 ********************************************************************************
 449 *
 450 *
 451 **** INITIALIZE MATRIX
 452 *
 453 *       THIS ROUTINE SHOULD BE IMPROVED BY SUPPLYING
 454 *       A FLOATING POINT 1.0 CONSTANT!
 455 *
 456 ****************************************
 457 *
 458 INIT    DAC     **
 459         LDX*    INIT    LOAD INDEX REGISTER WITH ADDRESS OF MATRIX
 460         IRS     INIT    CORRECT RETURN ADDRESS
 461 *
 462         CRA             INITIALISE
 463         STA     1,1     A11, LOWER BITS
 464         STA     2,1     A12
 465         STA     3,1
 466         STA     4,1     A21
 467         STA     5,1
 468         STA     7,1     A22, LOWER BITS
 469 *
 470         LDA     ONEF    FLOATING POINT 1.0 CONSTANT
 471         STA     0,1     A11, UPPER BITS
 472         STA     6,1     A22, UPPER BITS
 473 *
 474         JMP*    INIT    RETURN.
 475 *
 476 *
 477 ********************************************************************************
 478 *
 479 *
 480 **** MATRIX MULTIPLICATION
 481 *
 482 *     C =      A      *      B
 483 *
 484 *         | a11 a12 |   | b11 b12 |
 485 *       = |         | * |         |
 486 *         | a21 a22 |   | b21 b22 |
 487 *
 488 *         | (a11*b11) (a21*b12) |
 489 *       = |                     |
 490 *         | (a12*b21) (a22*b22) |
 491 *
 492 * CALL:
 493 *       JST MUL
 494 *       DAC MC
 495 *       DAC MA
 496 *       DAC MB
 497 *
 498 ****************************************
 499 *
 500 MUL     DAC     **
 501         LDX*    MUL
 502 *
 503         LDA*    MUL
 504         STA     PC11
 505         ADD     =2
 506         STA     PC12
 507         ADD     =2
 508         STA     PC21
 509         ADD     =2
 510         STA     PC22
 511         IRS     MUL
 512 *
 513         LDA*    MUL
 514         STA     PA11
 515         ADD     =2
 516         STA     PA12
 517         ADD     =2
 518         STA     PA21
 519         ADD     =2
 520         STA     PA22
 521         ADD     =2
 522 *
 523         IRS     MUL
 524 *
 525         LDA*    MUL
 526         STA     PB11
 527         ADD     =2
 528         STA     PB12
 529         ADD     =2
 530         STA     PB21
 531         ADD     =2
 532         STA     PB22
 533         ADD     =2
 534 *
 535         IRS     MUL
 536         IRS     MUL
 537 *
 538 *  a11 a12  b11 b12   a11*b11 a21*b12
 539 *  a21 a22  b21 b22   a12*b21 a22*b22
 540 *
 541         CALL    L$22    LOAD REAL
 542 PA11    DAC     0
 543         CALL    M$22    MULTIPLY
 544 PB11    DAC     0
 545         CALL    H$22    STORE
 546 PC11    DEC     0
 547 *
 548         CALL    L$22
 549 PA21    DEC     0
 550         CALL    M$22
 551 PB12    DEC     0
 552         CALL    H$22
 553 PC12    DEC     0
 554 *
 555         CALL    L$22
 556 PA12    DEC     0
 557         CALL    M$22
 558 PB21    DEC     0
 559         CALL    H$22
 560 PC21    DEC     0
 561 *
 562         CALL    L$22
 563 PA22    DEC     0
 564         CALL    M$22
 565 PB22    DEC     0
 566         CALL    H$22
 567 PC22    DEC     0
 568 *
 569 *
 570         JMP*    MUL     RETURN.
 571 *
 572 *
 573 ********************************************************************************
 574 *
 575 *
 576 **** SCALE MATRIX
 577 *
 578 SCLE    DAC     **      SCALE MATRIX
 579 *
 580         LDA*    SCLE    GET MATRIX BASE ADDRESS
 581         STA     SM11
 582         STA     TM11
 583         ADD     =2
 584         STA     SM12
 585         STA     TM12
 586         ADD     =2
 587         STA     SM21
 588         STA     TM21
 589         ADD     =2
 590         STA     SM22
 591         STA     TM22
 592         IRS     SCLE
 593         LDA*    SCLE
 594         STA     S1
 595         STA     S2
 596         STA     S3
 597         STA     S4
 598         IRS     SCLE    TALLY RETURN ADDRESS
 599         IRS     SCLE    AGAIN
 600 *
 601         CALL    L$22
 602 SM11    DAC     **
 603         CALL    M$22
 604 S1      DAC     **
 605         CALL    H$22
 606 TM11    DAC     **
 607 *
 608         CALL    L$22
 609 SM12    DAC     **
 610         CALL    M$22
 611 S2      DAC     **
 612         CALL    H$22
 613 TM12    DAC     **
 614 *
 615         CALL    L$22
 616 SM21    DAC     **
 617         CALL    M$22
 618 S3      DAC     **
 619         CALL    H$22
 620 TM21    DAC     **
 621 *
 622         CALL    L$22
 623 SM22    DAC     **
 624         CALL    M$22
 625 S4      DAC     **
 626         CALL    H$22
 627 TM22    DAC     **
 628 *
 629         JMP*    SCLE
 630 *
 631 *
 632 ********************************************************************************
 633 *
 634 *
 635 **** ADD ROTATION TO MATRIX
 636 *
 637 *
 638 *    M =      M      *          MROT
 639 *
 640 *        | M11 M12 |   | COS(X)  -SIN(X)|
 641 *      = |         | * |                |
 642 *        | M21 M22 |   | SIN( X)  COS(X)|
 643 *
 644 *        | M11*COS(X)+M12*SIN(X)  M12*COS(X)-M11*SIN(X) |
 645 *      = |                                              |
 646 *        | M21*COS(X)+M22*SIN(X)  M22*COS(X)-M21*SIN(X) |
 647 *
 648 * CALL:
 649 *       JST     ROT
 650 *       DAC     MATRIX
 651 *       DAC     ANGLE
 652 *       DAC     0       DON'T FORGET!
 653 *
 654 ****************************************
 655 *
 656 ROT     DAC     **      ENTRY
 657 *
 658         LDA*    ROT     GET MATRIX POINTER
 659         STA     R111    M11, FIRST COPY
 660         STA     R211    M11, SECOND COPY
 661         STA     R311    M11, THIRD COPY
 662         ADD     =2
 663         STA     R112
 664         STA     R212
 665         STA     R312
 666         STA     R412
 667         ADD     =2
 668         STA     R121
 669         STA     R221
 670         STA     R321
 671         ADD     =2
 672         STA     R122
 673         STA     R222
 674         STA     R322
 675         IRS     ROT
 676         LDA*    ROT
 677         STA     RA1
 678         STA     RA2
 679         IRS     ROT
 680         IRS     ROT
 681 *
 682 *
 683 **** M11 CALCULATION
 684 *
 685         CALL    SIN     FLOATING POINT SINE
 686 RA1     DAC     **      POINTER TO ANGLE
 687         CALL    H$22    SAVE TO TMP1
 688         DAC     TMP1
 689 *       CALL    L$22
 690 *       DAC     TMP1
 691         CALL    M$22    MULTIPLY
 692 R112    DAC     **      M12
 693         CALL    H$22    STORE TO TMP3
 694         DAC     TMP3
 695 *
 696 *************************************
 697 *
 698         CALL    COS     FLOATING POINT COSINE
 699 RA2     DAC     **      POINTER TO ANGLE
 700         CALL    H$22    SAVE TO TMP2
 701         DAC     TMP2
 702         CALL    M$22    MULTIPLY
 703 R111    DAC     **      M11
 704         CALL    A$22    ADD TMP3
 705         DAC     TMP3
 706         CALL    H$22    SAVE NEW M11 TO TMP3
 707         DAC     TMP3
 708 *
 709 *
 710 * M12 CALCULATION
 711 *
 712 * M12 = M12*COS(X)-M11*SIN(X)
 713 *
 714 *
 715         CALL    L$22    LOAD SINE
 716         DAC     TMP1
 717         CALL    M$22    MULTIPLY
 718 R211    DAC     **      M11
 719         CALL    H$22    STORE TO TMP4
 720         DAC     TMP4
 721         CALL    L$22    LOAD COSINE
 722         DAC     TMP2
 723         CALL    M$22    MULTIPLY
 724 R212    DAC     **
 725 *
 726         CALL    S$22    SUBSTRACT !!
 727         DAC     TMP4
 728 *
 729         CALL    H$22    SAVE TO NEW M12
 730 R312    DAC     **
 731 *
 732         CALL    L$22    LOAD NEW M11 FROM TMP3
 733         DAC     TMP3
 734         CALL    H$22    AND SAVE TO NEW M11
 735 R311    DAC     **
 736 *
 737 *
 738 * ******************************************
 739 *
 740 * M21 CALCULATION
 741 *
 742 * M21*COS(X)+M22*SIN(X)
 743 *
 744 * M22*SIN(X) -> TMP3
 745 * M21*COS(X) - TMP3
 746 *
 747 *
 748 *
 749         CALL    L$22    LOAD SINE
 750         DAC     TMP1
 751         CALL    M$22    MULTIPLY
 752 R122    DAC     **      M22
 753         CALL    H$22    STORE TO TMP3
 754         DAC     TMP3
 755         CALL    L$22    LOAD COSINE
 756         DAC     TMP2
 757         CALL    M$22    MULTIPLY
 758 R121    DAC     **      M11
 759         CALL    A$22    ADD TMP3
 760         DAC     TMP3
 761         CALL    H$22    SAVE NEW M21 TO TMP3
 762         DAC     TMP3
 763 *
 764 * M22 CALCULATION
 765 *
 766 * M22*COS(X)-M21*SIN(X)
 767 *
 768 *
 769 *       JMP     NN
 770         CALL    L$22    LOAD SINE
 771         DAC     TMP1
 772         CALL    M$22    MULTIPLY
 773 R221    DAC     **      M21
 774         CALL    H$22    STORE TO TMP4
 775         DAC     TMP4
 776         CALL    L$22    LOAD COSINE
 777         DAC     TMP2
 778         CALL    M$22    MULTIPLY
 779 R222    DAC     **
 780         CALL    S$22    SUBSTRACT
 781         DAC     TMP4
 782         CALL    H$22    SAVE TO NEW M22
 783 R322    DAC     **
 784         CALL    L$22    LOAD NEW M21 FROM TMP3
 785         DAC     TMP3
 786         CALL    H$22    AND SAVE TO NEW M21
 787 R321    DAC     **
 788 *
 789 *
 790         JMP*    ROT     RETURN.
 791 *
 792 R412    DAC     **
 793 *
 794 ********************************************************************************
 795 *
 796 *
 797 **** APPLY MATRIX TO PAIR OF INTEGERS
 798 *
 799 *       SETS UP MATRIX POINTERS AND VECTOR POINTERS.
 800 *       THEN IT CALLS APL, THE REAL WORKING ROUTINE.
 801 *
 802 * CALL:
 803 *       JST     M$APII
 804 *       DAC     MATRIX
 805 *       DAC     XO
 806 *       DAC     YO
 807 *       DAC     XI
 808 *       DAC     YI
 809 *       DAC     0       DON'T FORGET!
 810 *
 811 * USED VARIABLES: (TMP1) XOP,YOP,XP1,YP1,XP2,YP2
 812 *
 813 ****************************************
 814 *
 815 APII    DAC     **
 816 *
 817         LDA*    APII    POINTER TO MATRIX
 818         STA     MP11    STORE M11
 819         ADD     =2      ADD 2
 820         STA     MP12    STORE M12
 821         ADD     =2      ADD 2
 822         STA     MP21    STORE M21
 823         ADD     =2      ADD 2
 824         STA     MP22    STORE M22
 825         IRS     APII    JUMP TO NEXT ARGUMENT (X)
 826 *
 827         LDA*    APII    LOAD X VALUE
 828         STA     XOP     STORE TO X-POINTER
 829         IRS     APII    JUMP TO NEXT ARGUMENT (Y)
 830         LDA*    APII    LOAD Y VALUE
 831         STA     YOP     STORE TO Y-POINTER
 832         IRS     APII    CORRECT RETURN ADDRESS
 833 *
 834         LDA*    APII    LOAD X VALUE
 835         STA     XIP1    STORE TO X-POINTER
 836         STA     XIP2    STORE TO X-POINTER
 837         IRS     APII    JUMP TO NEXT ARGUMENT (Y)
 838         LDA*    APII    LOAD Y VALUE
 839         STA     YIP1    STORE TO Y-POINTER
 840         STA     YIP2    STORE TO Y-POINTER
 841         IRS     APII    CORRECT RETURN ADDRESS
 842 *
 843         IRS     APII    FOR FORTRANIV COMPATIBILITY
 844         JST     APL     CALL REAL ROUTINE
 845         JMP*    APII
 846 *
 847 ********************************************************************************
 848 *
 849 *
 850 **** APPLY MATRIX TO VECTOR
 851 *
 852 * SETS UP MATRIX POINTERS AND VECTOR POINTERS. THEN IT CALLS APL,
 853 * THE REAL WORKING ROUTINE.
 854 *
 855 * CALL:
 856 *       JST     M$APLI
 857 *       DAC     MATRIX
 858 *       DAC     TARGET
 859 *       DAC     SOURCE
 860 *       DAC     0       DON'T FORGET!
 861 *
 862 * USED VARIABLES: (TMP1) XOP,YOP,XP1,YP1,XP2,YP2
 863 *
 864 ****************************************
 865 *
 866 APLI    DAC     **
 867 *
 868         LDA*    APLI
 869         STA     MP11
 870         ADD     =2
 871         STA     MP12
 872         ADD     =2
 873         STA     MP21
 874         ADD     =2
 875         STA     MP22
 876         IRS     APLI
 877 *
 878         LDA*    APLI
 879         STA     XOP
 880         AOA
 881         STA     YOP
 882         IRS     APLI
 883 *
 884         LDA*    APLI
 885         STA     XIP1
 886         STA     XIP2
 887         AOA
 888         STA     YIP1
 889         STA     YIP2
 890         IRS     APLI
 891 *
 892         IRS     APLI
 893         JST     APL     CALL INTERNAL ROUTINE
 894         JMP*    APLI    RETURN.
 895 *
 896 *
 897 ********************************************************************************
 898 *
 899 *
 900 **** INTERNAL ROUTINE OF M$APL AND M$APII.
 901 *
 902 * ALL DATA IS SET UP BY THE BOTH USER ROUTINES ABOVE.
 903 *
 904 * USED VARIABLES: TMP1
 905 *
 906 ****************************************
 907 *
 908 APL     DAC     **
 909 *
 910         CALL    FLOAT   LOAD SINGLE PRECISION FLOAT FROM 1-WORD INTEGER
 911 XIP1    DAC     0
 912         CALL    M$22    MULTIPLY FLOAT*FLOAT
 913 MP11    DAC     0
 914         CALL    H$22    STORE FLOAT
 915         DAC     TMP1
 916         CALL    FLOAT
 917 YIP1    DAC     0
 918         CALL    M$22
 919 MP12    DAC     0
 920         CALL    A$22
 921         DAC     TMP1
 922         JST     RND     ROUND AND CONVERT TO INTEGER
 923         STA     PA21    STORE NEW X VALUE INTO TEMPORARY LOCATION
 924 ****
 925         CALL    FLOAT
 926 XIP2    DAC     0
 927         CALL    M$22
 928 MP21    DAC     0
 929         CALL    H$22
 930         DAC     TMP1
 931 *
 932         CALL    FLOAT
 933 YIP2    DAC     0
 934         CALL    M$22
 935 MP22    DAC     0
 936         CALL    A$22
 937         DAC     TMP1
 938         JST     RND     NOW INTEGER IN AC
 939         STA*    YOP     STORE NEW Y VALUE
 940 *
 941         LDA     PA21
 942         STA*    XOP
 943 *
 944         JMP*    APL     RETURN TO CALLER.
 945 *
 946 *
 947 ********************************************************************************
 948 *
 949 *
 950 **** M$ROTI ROTATE MATRIX, USE INTEGER DEGREE ANGLE
 951 *
 952 ROTI    DAC     **
 953         LDA*    ROTI    GET MATRIX POINTER
 954         STA     MTA     STORE TO ARGUMENT TO FINAL ROT
 955         IRS     ROTI    NEXT ARGUMENT: ANGLE
 956         LDA*    ROTI    LOAD ANGLE
 957         IRS     ROTI
 958         IRS     ROTI
 959         JST     RAD     CONVERT INTEGER TO RADIANT
 960         CALL    H$22
 961         DAC     RTMP
 962         JST     ROT
 963 MTA     DAC     **
 964         DAC     RTMP
 965         DAC     0
 966         JMP*    ROTI
 967 *
 968 RTMP    BSS     2       TEMPORARY VARIABLE
 969 *
 970 *
 971 ********************************************************************************
 972 *
 973 *
 974 **** M$SCLI - SCALE MATRIX, USE INTEGER PERCENT VALUE
 975 *
 976 SCLI    DAC     **
 977         LDA*    SCLI    GET MATRIX POINTER
 978         STA     MTSS    STORE TO ARGUMENT TO FINAL ROT
 979         IRS     SCLI    NEXT ARGUMENT: PERCENTS
 980 *
 981         LDA*    SCLI    LOAD PERCENTS
 982         STA     SA1     STORE
 983         CALL    FLOAT   CONVERT TO FLOAT
 984 SA1     DAC     **
 985         CALL    M$22    MULTIPLY WITH
 986         DAC     PERC    FACTOR 0.01
 987         IRS     SCLI
 988         IRS     SCLI
 989         CALL    H$22
 990         DAC     RTMP
 991 *
 992         JST     SCLE
 993 MTSS    DAC     **
 994         DAC     RTMP
 995         DAC     0
 996 *
 997         JMP*    SCLI    RETURN
 998 *
 999 *
1000 ********************************************************************************
1001 *
1002 *
1003 **** ROUND FLOAT TO INTEGER ROUTINE
1004 *
1005 * THERE IS NO CORRECTLY WORKING ROUNDING ROUTINE IN THE LIBRARY.
1006 * SO THIS IS A WORKAROUND. ADDS 0.5 TO THE VALUE AND USES ONE
1007 * ONE OF THE TRUNCATE AND CONVERT ROUTINES.
1008 * THE ARGUMENT IS IN REGISTERS A/B, THE RESULT IS PUT INTO A.
1009 *
1010 ****************************************
1011 *
1012 RND     DAC     **
1013         CALL    A$22    ADD
1014         DAC     HLF         0.5
1015         CALL    C$21    TRUNCATE TO INTEGER
1016         NOP
1017         JMP*    RND
1018 *
1019 *
1020 ********************************************************************************
1021 *
1022 *
1023 **** RAD - CONVERT ANGLE IN DEGREE TO RADIANT.
1024 *
1025 * ENTER WITH INTEGER ANGLE IN A
1026 *
1027 * CALL:
1028 *
1029 *       JST     RAD
1030 *       DAC     ANGLE   POINTER TO ANGLE
1031 *
1032 ****************************************
1033 *
1034 RAD     DAC     **
1035         STA     AN1
1036         CALL    FLOAT
1037 AN1     DAC     **
1038         CALL    M$22
1039         DAC     DEG
1040         JMP*    RAD
1041 *
1042 *
1043 ********************************************************************************
1044 *
1045 *
1046 **** CONSTANTS
1047 *
1048 ONE     DEC     1
1049 HLF     OCT     '040100 CONSTANT 0.5
1050         OCT     '000000
1051 ONEF    OCT     '040300 CONSTANT 1.0
1052         OCT     '000000
1053 DEG     OCT     '036707 CONSTANT PI/180
1054         OCT     '076432
1055 PERC    OCT     '036521 CONTANT 0.01
1056         OCT     '165605
1057 *
1058 *
1059 ********************************************************************************
1060 *
1061 *
1062 **** VARIABLES
1063 *
1064 TMP1    BSS     '2      TEMPORARY 2-WORD VARIABLE
1065 TMP2    BSS     '2            "      "      "
1066 TMP3    BSS     '2            "      "      "
1067 TMP4    BSS     '2            "      "      "
1068 VAP     DAC     **      TEMPORARY POINTER TO VECTOR
1069 XOP     DAC     **      OUTPUT VECTOR X POINTER
1070 YOP     DAC     **      OUTPUT VECTOR Y POINTER
1071 *VECP   DAC     **      VECTOR POINTER USED BY T$PII,T$PLI
1072 VECP    EQU     TMP2    VECTOR POINTER USED BY T$PII,T$PLI
1073 *
1074 *
1075 ********************************************************************************
1076 *
1077 *
1078 **** END OF THE LINE
1079 *
1080         END
1081 *
1082 *
1083 ********************************************************************************