![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to install.n CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / matlab|
Return to install.n CVS log | Up to [Research Unix] / researchv10dc / cmd / matlab |
1.1 ! root 1: .ds xl MATLAB Installation ! 2: .hy 0 ! 3: .de pp ! 4: .sp ! 5: .ti +5 ! 6: .. ! 7: .de hd ! 8: 'sp 2 ! 9: .if \\n%-1 'tl '\*(xl, page %' ! 10: .if !\\n%-1 'tl '\n(mo/\n(dy/\n(yr' ! 11: 'sp 3 ! 12: 'ns ! 13: .. ! 14: .de fo ! 15: 'bp ! 16: .. ! 17: .wh 0 hd ! 18: .wh -7 fo ! 19: \ ! 20: .sp 3 ! 21: .ce 2 ! 22: MATLAB Installation Guide ! 23: November, 1983 ! 24: .sp 2 ! 25: .ce 3 ! 26: Cleve Moler ! 27: Department of Computer Science ! 28: University of New Mexico ! 29: .sp 2 ! 30: .pp ! 31: The MATLAB tape is usually in one of two formats -- a UNIX "tar" tape, ! 32: or a "generic" tape with the following parameters: ! 33: ! 34: 9 track ! 35: 1600 bits per inch ! 36: no label ! 37: 80 characters per record ! 38: 1600 characters per block ! 39: 18 files in ASCII, followed by 18 files in EBCDIC ! 40: .pp ! 41: There are 36 files on the generic tape. The names of the first 18, and their ! 42: approximate sizes, are: ! 43: ! 44: 1. INSTALL 1100 lines ! 45: 2. MAT 3900 lines ! 46: 3. LIB 3339 lines ! 47: 4. HELPER.66 75 lines ! 48: 5. HELPER.77 120 lines ! 49: 6. HELP 750 lines ! 50: 7. SYS.UNIX 900 lines ! 51: 8. SYS.VMS 260 lines ! 52: 9. SYS.TSO 200 lines ! 53: 10. SYS.CMS 350 lines ! 54: 11. SYS.DEC10 250 lines ! 55: 12. SYS.CDC 200 lines ! 56: 13. SYS.PRIME 350 lines ! 57: 14. DOC 3960 lines ! 58: 15. DEMO 21 lines ! 59: 16. DOC.NROFF 3250 lines ! 60: 17. MAT.SNGL 3850 lines ! 61: 18. LIB.SNGL 3339 lines ! 62: ! 63: where a line is one 80 character record. ! 64: .pp ! 65: The first 18 files are in the ASCII character set. ! 66: The remaining 18 files are copies of the first 18 in EBCDIC. ! 67: .pp ! 68: INSTALL is this document. You can skip over it if you have this hard copy. ! 69: .pp ! 70: MAT, LIB, one of the versions of HELPER and one of the versions of SYS ! 71: together constitute the complete source code for the ! 72: double precision version of MATLAB. ! 73: .pp ! 74: The subroutines in MAT make up the parser and interpreter. ! 75: They include a COMMON statement which can be ! 76: changed to change the amount of memory allocated to variables. ! 77: .pp ! 78: The subroutines in LIB include modified versions of ! 79: the necessary routines from LINPACK, EISPACK and the BLAS. ! 80: These do not contain any COMMON statements and do not have to be ! 81: changed if the size of the stack is changed. ! 82: .pp ! 83: There are two versions of HELPER, the subroutine ! 84: which manages the help facility. ! 85: The version in HELPER.66 is written in Fortran 66 and ! 86: uses sequential i/o. ! 87: The version in HELPER.77 is written in Fortran 77 and uses ! 88: character variables and direct access i/o. ! 89: If your system supports ! 90: both versions, you will probably want to choose the direct access one -- ! 91: it should be much faster. ! 92: If you choose the direct access version, you will have to run ! 93: a preprocessor named HELPSET, which is also in file HELPER.77. ! 94: .pp ! 95: HELP is the source text for the help facility. It is read by the ! 96: sequential version of HELPER, or preprocessed by HELPSET into two files which ! 97: are then read by the direct access version of HELPER. HELP is also included as ! 98: an appendix in the User's Guide. ! 99: .pp ! 100: The subroutines in one of the versions of SYS ! 101: may have to be modified for your particular ! 102: operating system. They involve file access and floating point word format. ! 103: I have included versions that should work on several different ! 104: operating systems. Pick the version that is closest to your own ! 105: system and make any changes you need. ! 106: There are no machine dependent constants. ! 107: .pp ! 108: DOC is a report entitled "MATLAB Users' Guide". ! 109: It should be printed on a nice printer with upper and lower case; ! 110: there are 66 lines per page. ! 111: Make as many copies as you need, or order copies from us at New Mexico. ! 112: .pp ! 113: DEMO contains a demonstration exec file which can be accessed ! 114: by the exec command in MATLAB. ! 115: On most systems, all that is required is ! 116: EXEC('DEMO') or EXEC('DEMO',7). ! 117: On some systems, like TSO and NOS, it will be necessary ! 118: to attach file DEMO to unit 2 and then EXEC(2) or EXEC(2,7). ! 119: .pp ! 120: DOC.NROFF is the input to the UNIX text processing system ! 121: that was used to produce DOC. This may be useful if you want ! 122: to print the users' guide in a different format. ! 123: .pp ! 124: MAT.SNGL and LIB.SNGL are the single precision versions of MAT and LIB. ! 125: It is suggested that these be used only on systems with long words ! 126: (48 bit floating point fraction) or small memories. ! 127: .pp ! 128: The first thing to worry about is the character set. ! 129: The use of an upper-lower case character set is highly desirable, ! 130: but not essential. ! 131: Read the tape ! 132: and look at the first 50 or so lines of MAT. ! 133: This is the subroutine MATLAB, a listing ! 134: of which is included in this document. ! 135: Check the comments near the beginning to see if the special characters ! 136: are ok. The ones we have had trouble with include: ! 137: SEMI ; BSLASH \\ COLON : LESS < GREAT > ! 138: .br ! 139: Any characters which are not ok should be changed in the comment and ! 140: in the data statement which follows. ! 141: The alternate character set includes the lower case letters as well ! 142: as substitutes for some of the special characters, such as \\ and :, ! 143: which are not on some terminals. ! 144: Do not worry too much about the alternate character set now. ! 145: These data statements in subroutine MATLAB are the only place in the ! 146: source code where the special characters occur. ! 147: (If you want to get fancy, there is a data statement involving BEL ! 148: in subroutine ERROR near the end of file MAT. ! 149: Change 1H-blank to 1H-control G to get your terminal to ring its ! 150: bell for any error.) ! 151: .pp ! 152: The files DOC and HELP are full of special characters, including ! 153: < > [ ] : ; \\ | ! 154: .br ! 155: If they are not ok, I hope it is not too difficult to fix them up. ! 156: .pp ! 157: I have used several FORTRAN constructions which are only semi-standard, ! 158: and which may have to be changed for some systems: ! 159: Single quote (') in FORMATS instead of a tribute to Hollerith. ! 160: Entire arrays initialized in DATA statements. ! 161: Use of END= in READ statements. ! 162: .br ! 163: I have not asked PFORT to tell me what else is non-standard. ! 164: .pp ! 165: Some interactive FORTRAN systems use column 1 for carriage control and ! 166: others don't. If your system does not, edit file MAT and delete ! 167: all "1X," . There are 131 occurrences. ! 168: .pp ! 169: The main program in file SYS simply calls MATLAB. ! 170: It may have to be modified to control the printing of ! 171: underflow and overflow messages. ! 172: The ground rules are: Underflows are possible, but are harmless if ! 173: they are quietly set to zero. ! 174: Overflows are error conditions. It would be nice to print a message ! 175: and continue. ! 176: .pp ! 177: A listing of a typical version of SYS, ! 178: using some Fortran 77 for clarity, is included in this document. ! 179: I hope it is fairly easy to see what the various subroutines ! 180: do and how they have to be revised for your system. ! 181: Please send me copies of versions appropriate for your system. ! 182: .pp ! 183: The amount of memory required can be altered by a global text edit on MAT ! 184: which changes the matrix element stack length from ! 185: 5005 to something else. Be sure to get the statement ! 186: VSIZE = 5005 ! 187: .br ! 188: in the subroutine MATLAB. ! 189: With this setting of the stack length, MATLAB requires about a 300K byte ! 190: region on an IBM system. ! 191: The length has to be reduced somewhat to get MATLAB to fit ! 192: into a 64K word region on a CDC system. ! 193: Since each matrix element occupies two double or single precision words, ! 194: an increase of 1000 in the stack length requires an additional ! 195: 16K bytes or 2000 words. ! 196: .pp ! 197: It is possible to get by with less memory if you use overlays. ! 198: The simplest way to do this is the following. ! 199: ! 200: .ne 5 ! 201: ROOT ! 202: | ! 203: ------------------------------- ! 204: | | | | | | ! 205: S0 S1 S2 S3 S4 S5 ! 206: ! 207: Only ROOT plus one of the segments S0 through S5 need be in ! 208: memory at any one time. The segments do not call each other, ! 209: but return to the root. All the relevant calls are near the end ! 210: of subroutine MATLAB in the root. ! 211: There are five labeled COMMON blocks which are shared by the ! 212: root and all the segments. ! 213: The various segments consist of: ! 214: ! 215: .ne 7 ! 216: ROOT: ! 217: MAIN MATLAB STACK1 ! 218: PRINT PRNTID FUNS ! 219: STACKP ERROR FILES ! 220: HELPER PYTHAG FORMZ ! 221: FLOP PROMPT ! 222: Plus everything in file LIB not mentioned below. ! 223: ! 224: .ne 6 ! 225: S0: ! 226: PARSE COMAND CLAUSE ! 227: EXPR TERM FACTOR ! 228: STACKG STACK2 GETSYM ! 229: GETLIN GETCH GETVAL ! 230: EDIT XCHAR ! 231: ! 232: .ne 4 ! 233: S1: ! 234: MATFN1 WGECO WGEFA ! 235: WGESL WGEDI WPOFA ! 236: RREF HILBER ! 237: ! 238: .ne 3 ! 239: S2: ! 240: MATFN2 CORTH COMQR3 ! 241: HTRIDI HTRIBK IMTQL2 ! 242: ! 243: .ne 2 ! 244: S3: ! 245: MATFN3 WSVDC ! 246: ! 247: .ne 2 ! 248: S4: ! 249: MATFN4 WQRDC WQRSL ! 250: ! 251: .ne 4 ! 252: S5: ! 253: MATFN5 MATFN6 MAGIC ! 254: SAVLOD RAT USER ! 255: PLOT ! 256: ! 257: If you have enough room, combine ROOT and S0. ! 258: With more room, combine ROOT, S0 and S5. ! 259: If you use some overlay structure, please send me a description of ! 260: how it is done on your system. ! 261: .pp ! 262: In case anybody needs to know, here are the changes necessary ! 263: to convert from double to single precision. They can all be ! 264: safely accomplished by simple global text changes in MAT, LIB ! 265: and an appropriate version of SYS. ! 266: ! 267: DOUBLE PRECISION REAL ! 268: DOUBLE- REAL- ! 269: DSQRT SQRT ! 270: DLOG ALOG ! 271: DEXP EXP ! 272: DSIN SIN ! 273: DCOS COS ! 274: DATAN ATAN ! 275: DABS ABS ! 276: DMAX1 AMAX1 ! 277: DMIN1 AMIN1 ! 278: IDINT IFIX ! 279: DSIGN SIGN ! 280: DMOD AMOD ! 281: D0 E0 ! 282: D1 E1 ! 283: D2 E2 ! 284: D9 E9 ! 285: ! 286: .pp ! 287: Here are some additional comments that apply to individual systems. ! 288: .sp 2 ! 289: VAX UNIX. ! 290: .pp ! 291: If you have read the "tar" format tape, see file README and ! 292: the makefile. Ignore the rest of this section. ! 293: .pp ! 294: It is essential to change the single backslash \\ in the data ! 295: statement near the beginning of file MAT to a double backslash \\\\. ! 296: If this is not done, the F77 compiler produces an obscure error message ! 297: about "dataalpha" being too long. ! 298: .pp ! 299: Increase the size of the stack to take advantage of the virtual memory. ! 300: Eliminate all the "1X," in formats. ! 301: Change the statement ! 302: CASE = 0 in MATLAB to CASE = 1 to get lower case file names. ! 303: All these changes can be accomplished ! 304: by applying the following ed or vi commands to file MAT. ! 305: ! 306: 1,$s/\\/\\\\/g ! 307: 1,$s/5005/50005/g ! 308: 1,$s/1X,/0X,/g ! 309: 1,$s/CASE = 0/CASE = 1/ ! 310: 1,$s/BEL\/1H /BEL\/1H^G/ ! 311: 1,$s/LCT(2) = 25/LCT(2) = 25000/ ! 312: .pp ! 313: The compilation should suppress warnings about initializing non-character ! 314: variables with Hollerith and should use the Berkeley version of the ! 315: i/o support routines. This can be accomplished with: ! 316: ! 317: % f77 -w66 mat.f lib.f helper.f sys.f -lI77uc ! 318: .pp ! 319: Gary Klimowicz and Lee Ward of UNM have developed a overflow fault handler ! 320: for use with VAX UNIX. A copy of their C program in included in SYS.UNIX ! 321: and on the "tar" tape. ! 322: .sp 3 ! 323: VAX VMS ! 324: .pp ! 325: SYS.VMS contains an extra subroutine for proper handling of floating ! 326: point overflow. The main program includes a call to the system ! 327: which initializes this handling. ! 328: .pp ! 329: Integer overflow is expected in the the print routine and in ! 330: random number generator. ! 331: The integer overflow messages can be turned off by ! 332: ! 333: FORTRAN/NOCHECK MAT.FOR,LIB.FOR ! 334: .sp 3 ! 335: IBM (TSO) ! 336: .br ! 337: (Thanks to Jack Dongarra at Argonne.) ! 338: .pp ! 339: The main program in SYS.TSO includes the appropriate calls ! 340: to the IBM system utility ERRSET that turns off verbose ! 341: underflow and overflow messages. ! 342: .pp ! 343: Unfortunately, TSO does not have a mechanism for opening ! 344: files during execution. It is necessary to use file numbers with SAVE, ! 345: LOAD and EXEC. ! 346: .pp ! 347: We have to specify LRECL=80 for terminal input ! 348: on unit 5 to get blanks added to input lines. It is a good ! 349: idea to set up a clist something like the following. ! 350: ! 351: FREE FILE(FT05F001 FT06F001 FT09F001 FT01F001 FT02F001) ! 352: FREE ATTRLIST(AT80) ! 353: ATTR AT80 LRECL(80) BLKSIZE(80) RECFM(F) ! 354: ALLOC FILE(FT05F001) DA(*) USING(AT80) ! 355: ALLOC FILE(FT06F001) DA(*) ! 356: ALLOC FILE(FT09F001) DA('MATLAB.HELP.DATA') ! 357: ALLOC FILE(FT01F001) DA(SAVLOD.DATA) ! 358: ALLOC FILE(FT02F001) DA('MATLAB.DEMO.DATA') ! 359: CALL 'MATLAB.LOAD(MATMOD)' ! 360: ! 361: With this arrangement, the DEMO file can be executed by exec(2). ! 362: .sp 3 ! 363: IBM (CMS) ! 364: .br ! 365: (Thanks to Jack Dongarra at Argonne and David Gay at MIT.) ! 366: .pp ! 367: Entering a blank line in response to the MATLAB prompt generates ! 368: an end-of-file from terminal input (Fortran unit FT05F001). ! 369: This results in a call from GETLIN to FILES with LUNIT = -5. ! 370: The terminal is "rewound" and control eventually returned to PARSE ! 371: which prints another prompt. I hope this works. ! 372: .pp ! 373: An assembly language routine used to attach files with names generated ! 374: by MATLAB to Fortran unit numbers is included in SYS.CMS. ! 375: .sp 3 ! 376: DEC-10 ! 377: .br ! 378: (Thanks to Stan Eisenstat and Craig Douglas at Yale.) ! 379: .pp ! 380: The hyperbolic trig functions SINH and COSH are not available ! 381: on the DEC system. Fortran subroutines are included in the SYS.DEC10 file. ! 382: .sp 3 ! 383: PRIME 400 ! 384: .br ! 385: (Thanks to Richard Franke and Drexel University.) ! 386: .pp ! 387: The terminal is Fortran I/O unit number 1. ! 388: Subroutine MATLAB has to be changed so that ! 389: RTE = 5 becomes RTE = 1 ! 390: WTE = 6 becomes WTE = 1 ! 391: .br ! 392: Subroutine MATFN5 has to be changed so that ! 393: WIO = 1 becomes WIO = 8 ! 394: LUNIT = 1 becomes LUNIT = 8 (in two places). ! 395: .sp 3 ! 396: CDC ! 397: .pp ! 398: CDC systems offer exciting challenges as far as portability is concerned. ! 399: The first question is: which character set should be used? ! 400: An easy approach is to convert everything to the venerable 6-bit character set. ! 401: Even so, you may have trouble ! 402: with the colon, which is a pretty important MATLAB character. ! 403: It is far more fun to try to use upper and lower case and all ! 404: the special symbols. ! 405: I have succeeded in doing this ! 406: with the 6/12-bit setup used on the NOS system at Sandia, ! 407: but have given up with the 6/18-bit coding on LTSS at Los Alamos. ! 408: .pp ! 409: In "ASCII" mode on NOS, lower case characters are represented by ! 410: 12 bits -- the first 6 bits are octal 76 and the last 6 are the ! 411: corresponding upper case character. They count as two characters. ! 412: So, the following changes are required in file MAT. Several of ! 413: the mixed case strings in FORMAT statements extend beyond ! 414: column 72. You might as well convert these to all upper case. ! 415: All the 80A1's in FORMATS should be changed to 132A1's and ! 416: all the DATA statements initializing LRECL should be changed from 80 to 132. ! 417: The DATA statement for ALPHB in subroutine MATLAB can be changed to ! 418: have all upper case alphabetic characters because subroutine XCHAR ! 419: will catch the prefix octal 76. ! 420: .pp ! 421: An important change involves our friend the colon, which becomes ! 422: a 12-bit octal 7404. In the DATA statement for ALPHA, make the ! 423: element just before 1H+ into a 1H(percent sign). ! 424: And, in the DATA statement for ALPHB, make the corresponding element ! 425: into a 2H(colon). ! 426: Then read the comments in subroutine XCHAR in file SYS.CDC and make ! 427: sure that the DATA statements there are correct. ! 428: .pp ! 429: The FTN5 compiler should take MATLAB pretty much is it is. ! 430: The older FTN compiler requires two familiar changes to the ! 431: entire source code. First, the END= in the READ statements have ! 432: to be replaced by IF (EOF) GO TO ... . ! 433: Second, the single quotes in FORMATS have to be replaced with ! 434: asterisks. ! 435: .sp 3 ! 436: Good luck. Please let me know what difficulties you have, and what ! 437: I have left out of this guide. You can call me at: ! 438: 505-268-8631 (home) ! 439: 505-277-3112 (office) ! 440: ! 441: ------------ ! 442: .pp ! 443: The support of the National Science Foundation and the use of ! 444: facilities at Argonne National Laboratory, Los Alamos National Laboratory ! 445: and Stanford Linear Accelerator Center is gratefully acknowledged. ! 446: So is the assistance of the many people who have installed early ! 447: versions of MATLAB. ! 448: .bp ! 449: .ll 80 ! 450: .nf ! 451: Contents of file MAT: ! 452: ! 453: SUBROUTINE MATLAB(INIT) ! 454: SUBROUTINE PARSE ! 455: SUBROUTINE COMAND(ID) ! 456: SUBROUTINE CLAUSE ! 457: SUBROUTINE EXPR ! 458: SUBROUTINE TERM ! 459: SUBROUTINE FACTOR ! 460: SUBROUTINE FUNS(ID) ! 461: SUBROUTINE STACKP(ID) ! 462: SUBROUTINE STACKG(ID) ! 463: SUBROUTINE STACK1(OP) ! 464: SUBROUTINE STACK2(OP) ! 465: SUBROUTINE PRINT(ID,K) ! 466: SUBROUTINE PRNTID(ID,ARGCNT) ! 467: SUBROUTINE GETSYM ! 468: SUBROUTINE GETLIN ! 469: SUBROUTINE GETCH ! 470: SUBROUTINE GETVAL(S) ! 471: SUBROUTINE MATFN1 ! 472: SUBROUTINE MATFN2 ! 473: SUBROUTINE MATFN3 ! 474: SUBROUTINE MATFN4 ! 475: SUBROUTINE MATFN5 ! 476: SUBROUTINE MATFN6 ! 477: SUBROUTINE ERROR(N) ! 478: DOUBLE PRECISION FUNCTION PYTHAG(A,B) ! 479: SUBROUTINE RAT(X,LEN,MAXD,D) ! 480: ! 481: Contents of file HELPER.66: ! 482: ! 483: SUBROUTINE HELPER(H) -- Sequential version ! 484: ! 485: Contents of file HELPER.77: ! 486: ! 487: PROGRAM HLPSET -- Direct access setup ! 488: SUBROUTINE HELPER(H) -- Direct access version ! 489: ! 490: Contents of file SYS: ! 491: ! 492: PROGRAM MAIN ! 493: SUBROUTINE FILES(LUNIT,NAME) ! 494: SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG) ! 495: SUBROUTINE FORMZ(LUNIT,X,Y) ! 496: DOUBLE PRECISION FUNCTION FLOP(X) ! 497: SUBROUTINE XCHAR(BUF,K) ! 498: SUBROUTINE USER(A,M,N,S,T) ! 499: SUBROUTINE PROMPT(PAUSE) ! 500: SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF) ! 501: SUBROUTINE EDIT(BUF,N) ! 502: .bp ! 503: Contents of file LIB: ! 504: ! 505: SUBROUTINE WGECO(AR,AI,LDA,N,IPVT,RCOND,ZR,ZI) ! 506: SUBROUTINE WGEFA(AR,AI,LDA,N,IPVT,INFO) ! 507: SUBROUTINE WGESL(AR,AI,LDA,N,IPVT,BR,BI,JOB) ! 508: SUBROUTINE WGEDI(AR,AI,LDA,N,IPVT,DETR,DETI,WORKR,WORKI,JOB) ! 509: SUBROUTINE WPOFA(AR,AI,LDA,N,INFO) ! 510: SUBROUTINE RREF(AR,AI,LDA,M,N,EPS) ! 511: SUBROUTINE HILBER(A,LDA,N) ! 512: SUBROUTINE HTRIDI(NM,N,AR,AI,D,E,E2,TAU) ! 513: SUBROUTINE HTRIBK(NM,N,AR,AI,TAU,M,ZR,ZI) ! 514: SUBROUTINE IMTQL2(NM,N,D,E,Z,IERR,JOB) ! 515: SUBROUTINE CORTH(NM,N,LOW,IGH,AR,AI,ORTR,ORTI) ! 516: SUBROUTINE COMQR3(NM,N,LOW,IGH,ORTR,ORTI,HR,HI,WR,WI,ZR,ZI,IERR ! 517: SUBROUTINE WSVDC(XR,XI,LDX,N,P,SR,SI,ER,EI,UR,UI,LDU,VR,VI,LDV, ! 518: SUBROUTINE WQRDC(XR,XI,LDX,N,P,QRAUXR,QRAUXI,JPVT,WORKR,WORKI, ! 519: SUBROUTINE WQRSL(XR,XI,LDX,N,K,QRAUXR,QRAUXI,YR,YI,QYR,QYI,QTYR, ! 520: SUBROUTINE MAGIC(A,LDA,N) ! 521: SUBROUTINE BASE(X,B,EPS,S,N) ! 522: DOUBLE PRECISION FUNCTION URAND(IY) ! 523: SUBROUTINE WMUL(AR,AI,BR,BI,CR,CI) ! 524: SUBROUTINE WDIV(AR,AI,BR,BI,CR,CI) ! 525: SUBROUTINE WSIGN(XR,XI,YR,YI,ZR,ZI) ! 526: SUBROUTINE WSQRT(XR,XI,YR,YI) ! 527: SUBROUTINE WLOG(XR,XI,YR,YI) ! 528: SUBROUTINE WATAN(XR,XI,YR,YI) ! 529: DOUBLE PRECISION FUNCTION WNRM2(N,XR,XI,INCX) ! 530: DOUBLE PRECISION FUNCTION WASUM(N,XR,XI,INCX) ! 531: INTEGER FUNCTION IWAMAX(N,XR,XI,INCX) ! 532: SUBROUTINE WRSCAL(N,S,XR,XI,INCX) ! 533: SUBROUTINE WSCAL(N,SR,SI,XR,XI,INCX) ! 534: SUBROUTINE WAXPY(N,SR,SI,XR,XI,INCX,YR,YI,INCY) ! 535: DOUBLE PRECISION FUNCTION WDOTUR(N,XR,XI,INCX,YR,YI,INCY) ! 536: DOUBLE PRECISION FUNCTION WDOTUI(N,XR,XI,INCX,YR,YI,INCY) ! 537: DOUBLE PRECISION FUNCTION WDOTCR(N,XR,XI,INCX,YR,YI,INCY) ! 538: DOUBLE PRECISION FUNCTION WDOTCI(N,XR,XI,INCX,YR,YI,INCY) ! 539: SUBROUTINE WCOPY(N,XR,XI,INCX,YR,YI,INCY) ! 540: SUBROUTINE WSET(N,XR,XI,YR,YI,INCY) ! 541: SUBROUTINE WSWAP(N,XR,XI,INCX,YR,YI,INCY) ! 542: SUBROUTINE RSET(N,DX,DY,INCY) ! 543: SUBROUTINE RSWAP(N,X,INCX,Y,INCY) ! 544: SUBROUTINE RROT(N,DX,INCX,DY,INCY,C,S) ! 545: SUBROUTINE RROTG(DA,DB,C,S) ! 546: LOGICAL FUNCTION EQID(X,Y) ! 547: SUBROUTINE PUTID(X,Y) ! 548: DOUBLE PRECISION FUNCTION ROUND(X) ! 549: .bp ! 550: First subroutine in file MAT: ! 551: ! 552: SUBROUTINE MATLAB(INIT) ! 553: C INIT = 0 FOR ORDINARY FIRST ENTRY ! 554: C = POSITIVE FOR SUBSEQUENT ENTRIES ! 555: C = NEGATIVE FOR SILENT INITIALIZATION (SEE MATZ) ! 556: C ! 557: DOUBLE PRECISION STKR(5005),STKI(5005) ! 558: INTEGER IDSTK(4,48),LSTK(48),MSTK(48),NSTK(48),VSIZE,LSIZE,BOT,TOP ! 559: INTEGER ALFA(52),ALFB(52),ALFL,CASE ! 560: INTEGER IDS(4,32),PSTK(32),RSTK(32),PSIZE,PT,PTZ ! 561: INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE,HIO ! 562: INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2) ! 563: COMMON /VSTK/ STKR,STKI,IDSTK,LSTK,MSTK,NSTK,VSIZE,LSIZE,BOT,TOP ! 564: COMMON /ALFS/ ALFA,ALFB,ALFL,CASE ! 565: COMMON /RECU/ IDS,PSTK,RSTK,PSIZE,PT,PTZ ! 566: COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE,HIO ! 567: COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN ! 568: C ! 569: DOUBLE PRECISION S,T ! 570: INTEGER EPS(4),FLOPS(4),EYE(4),RAND(4) ! 571: C ! 572: C CHARACTER SET ! 573: C 0 10 20 30 40 50 ! 574: C ! 575: C 0 0 A K U COLON : LESS < ! 576: C 1 1 B L V PLUS + GREAT > ! 577: C 2 2 C M W MINUS - ! 578: C 3 3 D N X STAR * ! 579: C 4 4 E O Y SLASH / ! 580: C 5 5 F P Z BSLASH \\ ! 581: C 6 6 G Q BLANK EQUAL = ! 582: C 7 7 H R LPAREN ( DOT . ! 583: C 8 8 I S RPAREN ) COMMA , ! 584: C 9 9 J T SEMI ; QUOTE ' ! 585: C ! 586: INTEGER ALPHA(52),ALPHB(52) ! 587: DATA ALPHA /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9, ! 588: $ 1HA,1HB,1HC,1HD,1HE,1HF,1HG,1HH,1HI,1HJ, ! 589: $ 1HK,1HL,1HM,1HN,1HO,1HP,1HQ,1HR,1HS,1HT, ! 590: $ 1HU,1HV,1HW,1HX,1HY,1HZ,1H ,1H(,1H),1H;, ! 591: $ 1H:,1H+,1H-,1H*,1H/,1H\\,1H=,1H.,1H,,1H', ! 592: $ 1H<,1H>/ ! 593: C ! 594: C ALTERNATE CHARACTER SET ! 595: C ! 596: DATA ALPHB /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9, ! 597: $ 1Ha,1Hb,1Hc,1Hd,1He,1Hf,1Hg,1Hh,1Hi,1Hj, ! 598: $ 1Hk,1Hl,1Hm,1Hn,1Ho,1Hp,1Hq,1Hr,1Hs,1Ht, ! 599: $ 1Hu,1Hv,1Hw,1Hx,1Hy,1Hz,1H ,1H(,1H),1H;, ! 600: $ 1H|,1H+,1H-,1H*,1H/,1H$,1H=,1H.,1H,,1H", ! 601: $ 1H[,1H]/ ! 602: C ! 603: DATA EPS/14,25,28,36/,FLOPS/15,21,24,25/ ! 604: DATA EYE/14,34,14,36/,RAND/27,10,23,13/ ! 605: C ! 606: IF (INIT .GT. 0) GO TO 90 ! 607: C ! 608: C RTE = UNIT NUMBER FOR TERMINAL INPUT ! 609: C WTE = UNIT NUMBER FOR TERMINAL OUTPUT ! 610: C HIO = UNIT NUMBER FOR HELP FILE ! 611: RTE = 5 ! 612: WTE = 6 ! 613: HIO = 9 ! 614: C ! 615: IF (INIT .GE. 0) WRITE(WTE,100) ! 616: 100 FORMAT(//1X,' < M A T L A B >' ! 617: $ /1X,' Version of --/--/--') ! 618: C ! 619: C ASK HELPER TO OPEN HELP FILE ! 620: BUF(1) = 0 ! 621: CALL HELPER(BUF) ! 622: C ! 623: C RANDOM NUMBER SEED ! 624: RAN(1) = 0 ! 625: C ! 626: C INITIAL LINE LIMIT ! 627: LCT(2) = 25 ! 628: C ! 629: ALFL = 52 ! 630: CASE = 1 ! 631: C CASE = 1 for file names in lower case ! 632: DO 20 I = 1, ALFL ! 633: ALFA(I) = ALPHA(I) ! 634: ALFB(I) = ALPHB(I) ! 635: 20 CONTINUE ! 636: C ! 637: VSIZE = 50005 ! 638: LSIZE = 48 ! 639: PSIZE = 32 ! 640: BOT = LSIZE-3 ! 641: CALL WSET(5,0.0D0,0.0D0,STKR(VSIZE-4),STKI(VSIZE-4),1) ! 642: CALL PUTID(IDSTK(1,LSIZE-3),EPS) ! 643: LSTK(LSIZE-3) = VSIZE-4 ! 644: MSTK(LSIZE-3) = 1 ! 645: NSTK(LSIZE-3) = 1 ! 646: S = 1.0D0 ! 647: 30 S = S/2.0D0 ! 648: T = 1.0D0 + S ! 649: IF (T .GT. 1.0D0) GO TO 30 ! 650: STKR(VSIZE-4) = 2.0D0*S ! 651: CALL PUTID(IDSTK(1,LSIZE-2),FLOPS) ! 652: LSTK(LSIZE-2) = VSIZE-3 ! 653: MSTK(LSIZE-2) = 1 ! 654: NSTK(LSIZE-2) = 2 ! 655: CALL PUTID(IDSTK(1,LSIZE-1), EYE) ! 656: LSTK(LSIZE-1) = VSIZE-1 ! 657: MSTK(LSIZE-1) = -1 ! 658: NSTK(LSIZE-1) = -1 ! 659: STKR(VSIZE-1) = 1.0D0 ! 660: CALL PUTID(IDSTK(1,LSIZE), RAND) ! 661: LSTK(LSIZE) = VSIZE ! 662: MSTK(LSIZE) = 1 ! 663: NSTK(LSIZE) = 1 ! 664: FMT = 1 ! 665: FLP(1) = 0 ! 666: FLP(2) = 0 ! 667: DDT = 0 ! 668: RAN(2) = 0 ! 669: PTZ = 0 ! 670: PT = PTZ ! 671: ERR = 0 ! 672: RIO = RTE ! 673: WIO = 0 ! 674: IF (INIT .LT. 0) RETURN ! 675: C ! 676: 90 CALL PARSE ! 677: IF (FUN .EQ. 1) CALL MATFN1 ! 678: IF (FUN .EQ. 2) CALL MATFN2 ! 679: IF (FUN .EQ. 3) CALL MATFN3 ! 680: IF (FUN .EQ. 4) CALL MATFN4 ! 681: IF (FUN .EQ. 5) CALL MATFN5 ! 682: IF (FUN .EQ. 6) CALL MATFN6 ! 683: IF (FUN .EQ. 21) CALL MATFN1 ! 684: IF (FUN .NE. 99) GO TO 90 ! 685: RETURN ! 686: END ! 687: .bp ! 688: Typical file SYS (Nonstandard stuff in lower case): ! 689: ! 690: C PROGRAM MAIN ! 691: call overflow-control ! 692: CALL MATLAB(0) ! 693: STOP ! 694: END ! 695: ! 696: ! 697: SUBROUTINE FILES(LUNIT,NAME) ! 698: INTEGER LUNIT,NAME(32) ! 699: C ! 700: C SYSTEM DEPENDENT ROUTINE TO ALLOCATE FILES ! 701: C LUNIT = LOGICAL UNIT NUMBER ! 702: C NAME = FILE NAME, 1 CHARACTER PER WORD ! 703: C ! 704: character*32 nam ! 705: c ! 706: c close exec, save, load and print files ! 707: if (lunit .lt. 0) then ! 708: close(unit=-lunit) ! 709: return ! 710: end if ! 711: c ! 712: c Fortran 77 internal file conversion from 32a1 to character*32 ! 713: write(nam,'(32a1)') name ! 714: c ! 715: c formatted i/o for exec and print ! 716: if (lunit .gt. 2) open(unit=lunit,file=nam) ! 717: c ! 718: c unformatted i/o for save and load ! 719: if (lunit .le. 2) open(unit=lunit,file=nam,form='unformatted') ! 720: c ! 721: c rewind all except diary ! 722: if (lunit .ne. 8) rewind lunit ! 723: c ! 724: RETURN ! 725: END ! 726: ! 727: ! 728: SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG) ! 729: INTEGER LUNIT,ID(4),M,N,IMG,JOB ! 730: DOUBLE PRECISION XREAL(1),XIMAG(1) ! 731: C ! 732: C IMPLEMENT SAVE AND LOAD ! 733: C LUNIT = LOGICAL UNIT NUMBER ! 734: C ID = NAME, FORMAT 4A1 ! 735: C M, N = DIMENSIONS ! 736: C IMG = NONZERO IF XIMAG IS NONZERO ! 737: C JOB = 0 FOR SAVE ! 738: C = SPACE AVAILABLE FOR LOAD ! 739: C XREAL, XIMAG = REAL AND OPTIONAL IMAGINARY PARTS ! 740: C ! 741: C THIS VERSION USES UNFORMATTED READ AND WRITE ! 742: C ! 743: IF (JOB .GT. 0) GO TO 20 ! 744: C ! 745: C SAVE ! 746: 10 WRITE(LUNIT) ID,M,N,IMG ! 747: DO 15 J = 1, N ! 748: K = (J-1)*M+1 ! 749: L = J*M ! 750: WRITE(LUNIT) (XREAL(I),I=K,L) ! 751: IF (IMG .NE. 0) WRITE(LUNIT) (XIMAG(I),I=K,L) ! 752: 15 CONTINUE ! 753: RETURN ! 754: C ! 755: C LOAD ! 756: 20 READ(LUNIT,END=30) ID,M,N,IMG ! 757: IF (M*N .GT. JOB) GO TO 30 ! 758: DO 25 J = 1, N ! 759: K = (J-1)*M+1 ! 760: L = J*M ! 761: READ(LUNIT,END=30) (XREAL(I),I=K,L) ! 762: IF (IMG .NE. 0) READ(LUNIT,END=30) (XIMAG(I),I=K,L) ! 763: 25 CONTINUE ! 764: RETURN ! 765: C ! 766: C END OF FILE ! 767: 30 M = 0 ! 768: N = 0 ! 769: RETURN ! 770: END ! 771: ! 772: ! 773: SUBROUTINE FORMZ(LUNIT,X,Y) ! 774: DOUBLE PRECISION X,Y ! 775: C ! 776: C SYSTEM DEPENDENT ROUTINE TO PRINT WITH Z FORMAT ! 777: C ! 778: IF (Y .NE. 0.0D0) WRITE(LUNIT,10) X,Y ! 779: IF (Y .EQ. 0.0D0) WRITE(LUNIT,10) X ! 780: 10 format(2z18) ! 781: RETURN ! 782: END ! 783: ! 784: ! 785: DOUBLE PRECISION FUNCTION FLOP(X) ! 786: DOUBLE PRECISION X ! 787: C SYSTEM DEPENDENT FUNCTION ! 788: C COUNT AND POSSIBLY CHOP EACH FLOATING POINT OPERATION ! 789: C FLP(1) IS FLOP COUNTER ! 790: C FLP(2) IS NUMBER OF PLACES TO BE CHOPPED ! 791: C ! 792: INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2) ! 793: COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN ! 794: C ! 795: double precision mask(14),xx,mm ! 796: real mas(2,14) ! 797: logical lx(2),lm(2) ! 798: equivalence (lx(1),xx),(lm(1),mm) ! 799: equivalence (mask(1),mas(1)) ! 800: data mas/ ! 801: $ z'ffffffff',z'fff0ffff', ! 802: $ z'ffffffff',z'ff00ffff', ! 803: $ z'ffffffff',z'f000ffff', ! 804: $ z'ffffffff',z'0000ffff', ! 805: $ z'ffffffff',z'0000fff0', ! 806: $ z'ffffffff',z'0000ff00', ! 807: $ z'ffffffff',z'0000f000', ! 808: $ z'ffffffff',z'00000000', ! 809: $ z'fff0ffff',z'00000000', ! 810: $ z'ff00ffff',z'00000000', ! 811: $ z'f000ffff',z'00000000', ! 812: $ z'0000ffff',z'00000000', ! 813: $ z'0000fff0',z'00000000', ! 814: $ z'0000ff80',z'00000000'/ ! 815: C ! 816: FLP(1) = FLP(1) + 1 ! 817: K = FLP(2) ! 818: FLOP = X ! 819: IF (K .LE. 0) RETURN ! 820: FLOP = 0.0D0 ! 821: IF (K .GE. 15) RETURN ! 822: XX = X ! 823: MM = MASK(K) ! 824: LX(1) = and(LX(1),LM(1)) ! 825: LX(2) = and(LX(2),LM(2)) ! 826: FLOP = XX ! 827: RETURN ! 828: END ! 829: ! 830: ! 831: SUBROUTINE XCHAR(BUF,K) ! 832: INTEGER BUF(1),K ! 833: C ! 834: C SYSTEM DEPENDENT ROUTINE TO HANDLE SPECIAL CHARACTERS ! 835: C ! 836: INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE ! 837: COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE ! 838: write(WTE,10) buf(1) ! 839: 10 format(A1,' is not a MATLAB character.') ! 840: RETURN ! 841: END ! 842: ! 843: ! 844: SUBROUTINE USER(A,M,N,S,T) ! 845: DOUBLE PRECISION A(M,N),S,T ! 846: C ! 847: INTEGER A3(9) ! 848: DATA A3 /-149,537,-27,-50,180,-9,-154,546,-25/ ! 849: IF (A(1,1) .NE. 3.0D0) RETURN ! 850: DO 10 I = 1, 9 ! 851: A(I,1) = A3(I) ! 852: 10 CONTINUE ! 853: M = 3 ! 854: N = 3 ! 855: RETURN ! 856: END ! 857: ! 858: ! 859: SUBROUTINE PROMPT(PAUSE) ! 860: INTEGER PAUSE ! 861: C ! 862: C ISSUE MATLAB PROMPT WITH OPTIONAL PAUSE ! 863: C ! 864: INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE ! 865: COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE ! 866: WRITE(WTE,10) ! 867: IF (WIO .NE. 0) WRITE(WIO,10) ! 868: 10 FORMAT(1X,/'<>') ! 869: IF (PAUSE .EQ. 1) READ(RTE,20) DUMMY ! 870: 20 FORMAT(A1) ! 871: RETURN ! 872: END ! 873: ! 874: ! 875: SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF) ! 876: DOUBLE PRECISION X(N),Y(N),P(1) ! 877: INTEGER BUF(79) ! 878: C ! 879: C PLOT X VS. Y ON LUNIT ! 880: C IF K IS NONZERO, THEN P(1),...,P(K) ARE EXTRA PARAMETERS ! 881: C BUF IS WORK SPACE ! 882: C ! 883: DOUBLE PRECISION XMIN,YMIN,XMAX,YMAX,DY,DX,Y1,Y0 ! 884: INTEGER AST,BLANK,H,W ! 885: DATA AST/1H*/,BLANK/1H /,H/20/,W/79/ ! 886: C ! 887: C H = HEIGHT, W = WIDTH ! 888: C ! 889: XMIN = X(1) ! 890: XMAX = X(1) ! 891: YMIN = Y(1) ! 892: YMAX = Y(1) ! 893: DO 10 I = 1, N ! 894: XMIN = DMIN1(XMIN,X(I)) ! 895: XMAX = DMAX1(XMAX,X(I)) ! 896: YMIN = DMIN1(YMIN,Y(I)) ! 897: YMAX = DMAX1(YMAX,Y(I)) ! 898: 10 CONTINUE ! 899: DX = XMAX - XMIN ! 900: IF (DX .EQ. 0.0D0) DX = 1.0D0 ! 901: DY = YMAX - YMIN ! 902: WRITE(LUNIT,35) ! 903: DO 40 L = 1, H ! 904: DO 20 J = 1, W ! 905: BUF(J) = BLANK ! 906: 20 CONTINUE ! 907: Y1 = YMIN + (H-L+1)*DY/H ! 908: Y0 = YMIN + (H-L)*DY/H ! 909: JMAX = 1 ! 910: DO 30 I = 1, N ! 911: IF (Y(I) .GT. Y1) GO TO 30 ! 912: IF (L.NE.H .AND. Y(I).LE.Y0) GO TO 30 ! 913: J = 1 + (W-1)*(X(I) - XMIN)/DX ! 914: BUF(J) = AST ! 915: JMAX = MAX0(JMAX,J) ! 916: 30 CONTINUE ! 917: WRITE(LUNIT,35) (BUF(J),J=1,JMAX) ! 918: 35 FORMAT(1X,79A1) ! 919: 40 CONTINUE ! 920: RETURN ! 921: END ! 922: ! 923: ! 924: SUBROUTINE EDIT(BUF,N) ! 925: INTEGER BUF(N) ! 926: C ! 927: C CALLED AFTER INPUT OF A SINGLE BACKSLASH ! 928: C BUF CONTAINS PREVIOUS INPUT LINE, ONE CHAR PER WORD ! 929: C ENTER LOCAL EDITOR IF POSSIBLE ! 930: C ! 931: character*256 s ! 932: open(7,file='----') ! 933: write(7,10) (buf(i),i=1,n) ! 934: 10 format(256a1) ! 935: close(7) ! 936: call system('edit ----') ! 937: open(7,file='----') ! 938: rewind 7 ! 939: read(7,'(a)') s ! 940: close(7) ! 941: call system('remove ----') ! 942: n = 0 ! 943: do 20 i = 1, 256 ! 944: if (s(i:i) .ne. ' ') n = i ! 945: 20 continue ! 946: read(s,10) (buf(i),i=1,n) ! 947: RETURN ! 948: END
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.