# Category : Science and Education

Archive : MATLAB.ZIP

Filename : INSTALL.DOC

11/6/83

MATLAB Installation Guide

November, 1983

Cleve Moler

Department of Computer Science

University of New Mexico

The MATLAB tape is usually in one of two formats -- a UNIX

"tar" tape, or a "generic" tape with the following parameters:

9 track

1600 bits per inch

no label

80 characters per record

1600 characters per block

18 files in ASCII, followed by 18 files in EBCDIC

There are 36 files on the generic tape. The names of the

first 18, and their approximate sizes, are:

1. INSTALL 1100 lines

2. MAT 3900 lines

3. LIB 3339 lines

4. HELPER.66 75 lines

5. HELPER.77 120 lines

6. HELP 750 lines

7. SYS.UNIX 900 lines

8. SYS.VMS 260 lines

9. SYS.TSO 200 lines

10. SYS.CMS 350 lines

11. SYS.DEC10 250 lines

12. SYS.CDC 200 lines

13. SYS.PRIME 350 lines

14. DOC 3960 lines

15. DEMO 21 lines

16. DOC.NROFF 3250 lines

17. MAT.SNGL 3850 lines

18. LIB.SNGL 3339 lines

where a line is one 80 character record.

The first 18 files are in the ASCII character set. The

remaining 18 files are copies of the first 18 in EBCDIC.

INSTALL is this document. You can skip over it if you have

this hard copy.

MATLAB Installation, page 2

MAT, LIB, one of the versions of HELPER and one of the

versions of SYS together constitute the complete source code for

the double precision version of MATLAB.

The subroutines in MAT make up the parser and interpreter.

They include a COMMON statement which can be changed to change

the amount of memory allocated to variables.

The subroutines in LIB include modified versions of the

necessary routines from LINPACK, EISPACK and the BLAS. These do

not contain any COMMON statements and do not have to be changed

if the size of the stack is changed.

There are two versions of HELPER, the subroutine which

manages the help facility. The version in HELPER.66 is written

in Fortran 66 and uses sequential i/o. The version in HELPER.77

is written in Fortran 77 and uses character variables and direct

access i/o. If your system supports both versions, you will

probably want to choose the direct access one -- it should be

much faster. If you choose the direct access version, you will

have to run a preprocessor named HELPSET, which is also in file

HELPER.77.

HELP is the source text for the help facility. It is read

by the sequential version of HELPER, or preprocessed by HELPSET

into two files which are then read by the direct access version

of HELPER. HELP is also included as an appendix in the User's

Guide.

The subroutines in one of the versions of SYS may have to be

modified for your particular operating system. They involve file

access and floating point word format. I have included versions

that should work on several different operating systems. Pick

the version that is closest to your own system and make any

changes you need. There are no machine dependent constants.

DOC is a report entitled "MATLAB Users' Guide". It should

be printed on a nice printer with upper and lower case; there are

66 lines per page. Make as many copies as you need, or order

copies from us at New Mexico.

DEMO contains a demonstration exec file which can be

accessed by the exec command in MATLAB. On most systems, all that

is required is EXEC('DEMO') or EXEC('DEMO',7). On some systems,

like TSO and NOS, it will be necessary to attach file DEMO to

unit 2 and then EXEC(2) or EXEC(2,7).

DOC.NROFF is the input to the UNIX text processing system

that was used to produce DOC. This may be useful if you want to

print the users' guide in a different format.

MAT.SNGL and LIB.SNGL are the single precision versions of

MAT and LIB. It is suggested that these be used only on systems

MATLAB Installation, page 3

with long words (48 bit floating point fraction) or small

memories.

The first thing to worry about is the character set. The use

of an upper-lower case character set is highly desirable, but not

essential. Read the tape and look at the first 50 or so lines of

MAT. This is the subroutine MATLAB, a listing of which is

included in this document. Check the comments near the beginning

to see if the special characters are ok. The ones we have had

trouble with include:

SEMI ; BSLASH COLON : LESS < GREAT >

Any characters which are not ok should be changed in the comment

and in the data statement which follows. The alternate character

set includes the lower case letters as well as substitutes for

some of the special characters, such as and :, which are not on

some terminals. Do not worry too much about the alternate

character set now. These data statements in subroutine MATLAB

are the only place in the source code where the special

characters occur. (If you want to get fancy, there is a data

statement involving BEL in subroutine ERROR near the end of file

MAT. Change 1H-blank to 1H-control G to get your terminal to

ring its bell for any error.)

The files DOC and HELP are full of special characters,

including

< > \ ! : ;

If they are not ok, I hope it is not too difficult to fix them

up.

I have used several FORTRAN constructions which are only

semi-standard, and which may have to be changed for some systems:

Single quote (') in FORMATS instead of a tribute to Hollerith.

Entire arrays initialized in DATA statements.

Use of END= in READ statements.

I have not asked PFORT to tell me what else is non-standard.

Some interactive FORTRAN systems use column 1 for carriage

control and others don't. If your system does not, edit file MAT

and delete all "1X," . There are 131 occurrences.

The main program in file SYS simply calls MATLAB. It may

have to be modified to control the printing of underflow and

overflow messages. The ground rules are: Underflows are

possible, but are harmless if they are quietly set to zero.

Overflows are error conditions. It would be nice to print a

message and continue.

A listing of a typical version of SYS, using some Fortran 77

for clarity, is included in this document. I hope it is fairly

easy to see what the various subroutines do and how they have to

be revised for your system. Please send me copies of versions

appropriate for your system.

MATLAB Installation, page 4

The amount of memory required can be altered by a global

text edit on MAT which changes the matrix element stack length

from 5005 to something else. Be sure to get the statement

VSIZE = 5005

in the subroutine MATLAB. With this setting of the stack length,

MATLAB requires about a 300K byte region on an IBM system. The

length has to be reduced somewhat to get MATLAB to fit into a 64K

word region on a CDC system. Since each matrix element occupies

two double or single precision words, an increase of 1000 in the

stack length requires an additional 16K bytes or 2000 words.

It is possible to get by with less memory if you use

overlays. The simplest way to do this is the following.

ROOT

-------------------------------

S0 S1 S2 S3 S4 S5

Only ROOT plus one of the segments S0 through S5 need be in

memory at any one time. The segments do not call each other, but

return to the root. All the relevant calls are near the end of

subroutine MATLAB in the root. There are five labeled COMMON

blocks which are shared by the root and all the segments. The

various segments consist of:

ROOT:

MAIN MATLAB STACK1

PRINT PRNTID FUNS

STACKP ERROR FILES

HELPER PYTHAG FORMZ

FLOP PROMPT

Plus everything in file LIB not mentioned below.

S0:

PARSE COMAND CLAUSE

EXPR TERM FACTOR

STACKG STACK2 GETSYM

GETLIN GETCH GETVAL

EDIT XCHAR

S1:

MATFN1 WGECO WGEFA

WGESL WGEDI WPOFA

RREF HILBER

S2:

MATFN2 CORTH COMQR3

HTRIDI HTRIBK IMTQL2

S3:

MATFN3 WSVDC

MATLAB Installation, page 5

S4:

MATFN4 WQRDC WQRSL

S5:

MATFN5 MATFN6 MAGIC

SAVLOD RAT USER

PLOT

If you have enough room, combine ROOT and S0. With more room,

combine ROOT, S0 and S5. If you use some overlay structure,

please send me a description of how it is done on your system.

In case anybody needs to know, here are the changes

necessary to convert from double to single precision. They can

all be safely accomplished by simple global text changes in MAT,

LIB and an appropriate version of SYS.

DOUBLE PRECISION REAL

DOUBLE- REAL-

DSQRT SQRT

DLOG ALOG

DEXP EXP

DSIN SIN

DCOS COS

DATAN ATAN

DABS ABS

DMAX1 AMAX1

DMIN1 AMIN1

IDINT IFIX

DSIGN SIGN

DMOD AMOD

D0 E0

D1 E1

D2 E2

D9 E9

Here are some additional comments that apply to individual

systems.

VAX UNIX.

If you have read the "tar" format tape, see file README and

the makefile. Ignore the rest of this section.

It is essential to change the single backslash in the data

statement near the beginning of file MAT to a double backslash

. If this is not done, the F77 compiler produces an obscure

error message about "dataalpha" being too long.

Increase the size of the stack to take advantage of the

virtual memory. Eliminate all the "1X," in formats. Change the

MATLAB Installation, page 6

statement CASE = 0 in MATLAB to CASE = 1 to get lower case file

names. All these changes can be accomplished by applying the

following ed or vi commands to file MAT.

1,$s///g

1,$s/5005/50005/g

1,$s/1X,/0X,/g

1,$s/CASE = 0/CASE = 1/

1,$s/BEL/1H /BEL/1H^G/

1,$s/LCT(2) = 25/LCT(2) = 25000/

The compilation should suppress warnings about initializing

non-character variables with Hollerith and should use the

Berkeley version of the i/o support routines. This can be

accomplished with:

% f77 -w66 mat.f lib.f helper.f sys.f -lI77uc

Gary Klimowicz and Lee Ward of UNM have developed a overflow

fault handler for use with VAX UNIX. A copy of their C program

in included in SYS.UNIX and on the "tar" tape.

VAX VMS

SYS.VMS contains an extra subroutine for proper handling of

floating point overflow. The main program includes a call to the

system which initializes this handling.

Integer overflow is expected in the the print routine and in

random number generator. The integer overflow messages can be

turned off by

FORTRAN/NOCHECK MAT.FOR,LIB.FOR

IBM (TSO)

(Thanks to Jack Dongarra at Argonne.)

The main program in SYS.TSO includes the appropriate calls

to the IBM system utility ERRSET that turns off verbose underflow

and overflow messages.

Unfortunately, TSO does not have a mechanism for opening

files during execution. It is necessary to use file numbers with

SAVE, LOAD and EXEC.

We have to specify LRECL=80 for terminal input on unit 5 to

get blanks added to input lines. It is a good idea to set up a

clist something like the following.

MATLAB Installation, page 7

FREE FILE(FT05F001 FT06F001 FT09F001 FT01F001 FT02F001)

FREE ATTRLIST(AT80)

ATTR AT80 LRECL(80) BLKSIZE(80) RECFM(F)

ALLOC FILE(FT05F001) DA(*) USING(AT80)

ALLOC FILE(FT06F001) DA(*)

ALLOC FILE(FT09F001) DA('MATLAB.HELP.DATA')

ALLOC FILE(FT01F001) DA(SAVLOD.DATA)

ALLOC FILE(FT02F001) DA('MATLAB.DEMO.DATA')

CALL 'MATLAB.LOAD(MATMOD)'

With this arrangement, the DEMO file can be executed by exec(2).

IBM (CMS)

(Thanks to Jack Dongarra at Argonne and David Gay at MIT.)

Entering a blank line in response to the MATLAB prompt

generates an end-of-file from terminal input (Fortran unit

FT05F001). This results in a call from GETLIN to FILES with LUNIT

= -5. The terminal is "rewound" and control eventually returned

to PARSE which prints another prompt. I hope this works.

An assembly language routine used to attach files with names

generated by MATLAB to Fortran unit numbers is included in

SYS.CMS.

DEC-10

(Thanks to Stan Eisenstat and Craig Douglas at Yale.)

The hyperbolic trig functions SINH and COSH are not

available on the DEC system. Fortran subroutines are included in

the SYS.DEC10 file.

PRIME 400

(Thanks to Richard Franke and Drexel University.)

The terminal is Fortran I/O unit number 1. Subroutine

MATLAB has to be changed so that

RTE = 5 becomes RTE = 1

WTE = 6 becomes WTE = 1

Subroutine MATFN5 has to be changed so that

WIO = 1 becomes WIO = 8

LUNIT = 1 becomes LUNIT = 8 (in two places).

CDC

MATLAB Installation, page 8

CDC systems offer exciting challenges as far as portability

is concerned. The first question is: which character set should

be used? An easy approach is to convert everything to the

venerable 6-bit character set. Even so, you may have trouble

with the colon, which is a pretty important MATLAB character. It

is far more fun to try to use upper and lower case and all the

special symbols. I have succeeded in doing this with the 6/12-

bit setup used on the NOS system at Sandia, but have given up

with the 6/18-bit coding on LTSS at Los Alamos.

In "ASCII" mode on NOS, lower case characters are

represented by 12 bits -- the first 6 bits are octal 76 and the

last 6 are the corresponding upper case character. They count as

two characters. So, the following changes are required in file

MAT. Several of the mixed case strings in FORMAT statements

extend beyond column 72. You might as well convert these to all

upper case. All the 80A1's in FORMATS should be changed to

132A1's and all the DATA statements initializing LRECL should be

changed from 80 to 132. The DATA statement for ALPHB in

subroutine MATLAB can be changed to have all upper case

alphabetic characters because subroutine XCHAR will catch the

prefix octal 76.

An important change involves our friend the colon, which

becomes a 12-bit octal 7404. In the DATA statement for ALPHA,

make the element just before 1H+ into a 1H(percent sign). And,

in the DATA statement for ALPHB, make the corresponding element

into a 2H(colon). Then read the comments in subroutine XCHAR in

file SYS.CDC and make sure that the DATA statements there are

correct.

The FTN5 compiler should take MATLAB pretty much is it is.

The older FTN compiler requires two familiar changes to the

entire source code. First, the END= in the READ statements have

to be replaced by IF (EOF) GO TO ... . Second, the single quotes

in FORMATS have to be replaced with asterisks.

Good luck. Please let me know what difficulties you have, and

what I have left out of this guide. You can call me at:

505-268-8631 (home)

505-277-3112 (office)

------------

The support of the National Science Foundation and the use

of facilities at Argonne National Laboratory, Los Alamos National

Laboratory and Stanford Linear Accelerator Center is gratefully

acknowledged. So is the assistance of the many people who have

installed early versions of MATLAB.

MATLAB Installation, page 9

Contents of file MAT:

SUBROUTINE MATLAB(INIT)

SUBROUTINE PARSE

SUBROUTINE COMAND(ID)

SUBROUTINE CLAUSE

SUBROUTINE EXPR

SUBROUTINE TERM

SUBROUTINE FACTOR

SUBROUTINE FUNS(ID)

SUBROUTINE STACKP(ID)

SUBROUTINE STACKG(ID)

SUBROUTINE STACK1(OP)

SUBROUTINE STACK2(OP)

SUBROUTINE PRINT(ID,K)

SUBROUTINE PRNTID(ID,ARGCNT)

SUBROUTINE GETSYM

SUBROUTINE GETLIN

SUBROUTINE GETCH

SUBROUTINE GETVAL(S)

SUBROUTINE MATFN1

SUBROUTINE MATFN2

SUBROUTINE MATFN3

SUBROUTINE MATFN4

SUBROUTINE MATFN5

SUBROUTINE MATFN6

SUBROUTINE ERROR(N)

DOUBLE PRECISION FUNCTION PYTHAG(A,B)

SUBROUTINE RAT(X,LEN,MAXD,D)

Contents of file HELPER.66:

SUBROUTINE HELPER(H) -- Sequential version

Contents of file HELPER.77:

PROGRAM HLPSET -- Direct access setup

SUBROUTINE HELPER(H) -- Direct access version

Contents of file SYS:

PROGRAM MAIN

SUBROUTINE FILES(LUNIT,NAME)

SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG)

SUBROUTINE FORMZ(LUNIT,X,Y)

DOUBLE PRECISION FUNCTION FLOP(X)

SUBROUTINE XCHAR(BUF,K)

SUBROUTINE USER(A,M,N,S,T)

SUBROUTINE PROMPT(PAUSE)

SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF)

SUBROUTINE EDIT(BUF,N)

MATLAB Installation, page 10

Contents of file LIB:

SUBROUTINE WGECO(AR,AI,LDA,N,IPVT,RCOND,ZR,ZI)

SUBROUTINE WGEFA(AR,AI,LDA,N,IPVT,INFO)

SUBROUTINE WGESL(AR,AI,LDA,N,IPVT,BR,BI,JOB)

SUBROUTINE WGEDI(AR,AI,LDA,N,IPVT,DETR,DETI,WORKR,WORKI,JOB)

SUBROUTINE WPOFA(AR,AI,LDA,N,INFO)

SUBROUTINE RREF(AR,AI,LDA,M,N,EPS)

SUBROUTINE HILBER(A,LDA,N)

SUBROUTINE HTRIDI(NM,N,AR,AI,D,E,E2,TAU)

SUBROUTINE HTRIBK(NM,N,AR,AI,TAU,M,ZR,ZI)

SUBROUTINE IMTQL2(NM,N,D,E,Z,IERR,JOB)

SUBROUTINE CORTH(NM,N,LOW,IGH,AR,AI,ORTR,ORTI)

SUBROUTINE COMQR3(NM,N,LOW,IGH,ORTR,ORTI,HR,HI,WR,WI,ZR,ZI,IERR

SUBROUTINE WSVDC(XR,XI,LDX,N,P,SR,SI,ER,EI,UR,UI,LDU,VR,VI,LDV,

SUBROUTINE WQRDC(XR,XI,LDX,N,P,QRAUXR,QRAUXI,JPVT,WORKR,WORKI,

SUBROUTINE WQRSL(XR,XI,LDX,N,K,QRAUXR,QRAUXI,YR,YI,QYR,QYI,QTYR,

SUBROUTINE MAGIC(A,LDA,N)

SUBROUTINE BASE(X,B,EPS,S,N)

DOUBLE PRECISION FUNCTION URAND(IY)

SUBROUTINE WMUL(AR,AI,BR,BI,CR,CI)

SUBROUTINE WDIV(AR,AI,BR,BI,CR,CI)

SUBROUTINE WSIGN(XR,XI,YR,YI,ZR,ZI)

SUBROUTINE WSQRT(XR,XI,YR,YI)

SUBROUTINE WLOG(XR,XI,YR,YI)

SUBROUTINE WATAN(XR,XI,YR,YI)

DOUBLE PRECISION FUNCTION WNRM2(N,XR,XI,INCX)

DOUBLE PRECISION FUNCTION WASUM(N,XR,XI,INCX)

INTEGER FUNCTION IWAMAX(N,XR,XI,INCX)

SUBROUTINE WRSCAL(N,S,XR,XI,INCX)

SUBROUTINE WSCAL(N,SR,SI,XR,XI,INCX)

SUBROUTINE WAXPY(N,SR,SI,XR,XI,INCX,YR,YI,INCY)

DOUBLE PRECISION FUNCTION WDOTUR(N,XR,XI,INCX,YR,YI,INCY)

DOUBLE PRECISION FUNCTION WDOTUI(N,XR,XI,INCX,YR,YI,INCY)

DOUBLE PRECISION FUNCTION WDOTCR(N,XR,XI,INCX,YR,YI,INCY)

DOUBLE PRECISION FUNCTION WDOTCI(N,XR,XI,INCX,YR,YI,INCY)

SUBROUTINE WCOPY(N,XR,XI,INCX,YR,YI,INCY)

SUBROUTINE WSET(N,XR,XI,YR,YI,INCY)

SUBROUTINE WSWAP(N,XR,XI,INCX,YR,YI,INCY)

SUBROUTINE RSET(N,DX,DY,INCY)

SUBROUTINE RSWAP(N,X,INCX,Y,INCY)

SUBROUTINE RROT(N,DX,INCX,DY,INCY,C,S)

SUBROUTINE RROTG(DA,DB,C,S)

LOGICAL FUNCTION EQID(X,Y)

SUBROUTINE PUTID(X,Y)

DOUBLE PRECISION FUNCTION ROUND(X)

MATLAB Installation, page 11

First subroutine in file MAT:

SUBROUTINE MATLAB(INIT)

C INIT = 0 FOR ORDINARY FIRST ENTRY

C = POSITIVE FOR SUBSEQUENT ENTRIES

C = NEGATIVE FOR SILENT INITIALIZATION (SEE MATZ)

C

DOUBLE PRECISION STKR(5005),STKI(5005)

INTEGER IDSTK(4,48),LSTK(48),MSTK(48),NSTK(48),VSIZE,LSIZE,BOT,TOP

INTEGER ALFA(52),ALFB(52),ALFL,CASE

INTEGER IDS(4,32),PSTK(32),RSTK(32),PSIZE,PT,PTZ

INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE,HIO

INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2)

COMMON /VSTK/ STKR,STKI,IDSTK,LSTK,MSTK,NSTK,VSIZE,LSIZE,BOT,TOP

COMMON /ALFS/ ALFA,ALFB,ALFL,CASE

COMMON /RECU/ IDS,PSTK,RSTK,PSIZE,PT,PTZ

COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE,HIO

COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN

C

DOUBLE PRECISION S,T

INTEGER EPS(4),FLOPS(4),EYE(4),RAND(4)

C

C CHARACTER SET

C 0 10 20 30 40 50

C

C 0 0 A K U COLON : LESS <

C 1 1 B L V PLUS + GREAT >

C 2 2 C M W MINUS -

C 3 3 D N X STAR *

C 4 4 E O Y SLASH /

C 5 5 F P Z BSLASH

C 6 6 G Q BLANK EQUAL =

C 7 7 H R LPAREN ( DOT .

C 8 8 I S RPAREN ) COMMA ,

C 9 9 J T SEMI ; QUOTE '

C

INTEGER ALPHA(52),ALPHB(52)

DATA ALPHA /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9,

$ 1HA,1HB,1HC,1HD,1HE,1HF,1HG,1HH,1HI,1HJ,

$ 1HK,1HL,1HM,1HN,1HO,1HP,1HQ,1HR,1HS,1HT,

$ 1HU,1HV,1HW,1HX,1HY,1HZ,1H ,1H(,1H),1H;,

$ 1H:,1H+,1H-,1H*,1H/,1H,1H=,1H.,1H,,1H',

$ 1H<,1H>/

C

C ALTERNATE CHARACTER SET

C

DATA ALPHB /1H0,1H1,1H2,1H3,1H4,1H5,1H6,1H7,1H8,1H9,

$ 1Ha,1Hb,1Hc,1Hd,1He,1Hf,1Hg,1Hh,1Hi,1Hj,

$ 1Hk,1Hl,1Hm,1Hn,1Ho,1Hp,1Hq,1Hr,1Hs,1Ht,

$ 1Hu,1Hv,1Hw,1Hx,1Hy,1Hz,1H ,1H(,1H),1H;,

$ 1H,1H+,1H-,1H*,1H/,1H$,1H=,1H.,1H,,1H",

$ 1H\,1H!/

C

MATLAB Installation, page 12

DATA EPS/14,25,28,36/,FLOPS/15,21,24,25/

DATA EYE/14,34,14,36/,RAND/27,10,23,13/

C

IF (INIT .GT. 0) GO TO 90

C

C RTE = UNIT NUMBER FOR TERMINAL INPUT

C WTE = UNIT NUMBER FOR TERMINAL OUTPUT

C HIO = UNIT NUMBER FOR HELP FILE

RTE = 5

WTE = 6

HIO = 9

C

IF (INIT .GE. 0) WRITE(WTE,100)

100 FORMAT(//1X,' < M A T L A B >'

$ /1X,' Version of --/--/--')

C

C ASK HELPER TO OPEN HELP FILE

BUF(1) = 0

CALL HELPER(BUF)

C

C RANDOM NUMBER SEED

RAN(1) = 0

C

C INITIAL LINE LIMIT

LCT(2) = 25

C

ALFL = 52

CASE = 1

C CASE = 1 for file names in lower case

DO 20 I = 1, ALFL

ALFA(I) = ALPHA(I)

ALFB(I) = ALPHB(I)

20 CONTINUE

C

VSIZE = 50005

LSIZE = 48

PSIZE = 32

BOT = LSIZE-3

CALL WSET(5,0.0D0,0.0D0,STKR(VSIZE-4),STKI(VSIZE-4),1)

CALL PUTID(IDSTK(1,LSIZE-3),EPS)

LSTK(LSIZE-3) = VSIZE-4

MSTK(LSIZE-3) = 1

NSTK(LSIZE-3) = 1

S = 1.0D0

30 S = S/2.0D0

T = 1.0D0 + S

IF (T .GT. 1.0D0) GO TO 30

STKR(VSIZE-4) = 2.0D0*S

CALL PUTID(IDSTK(1,LSIZE-2),FLOPS)

LSTK(LSIZE-2) = VSIZE-3

MSTK(LSIZE-2) = 1

NSTK(LSIZE-2) = 2

CALL PUTID(IDSTK(1,LSIZE-1), EYE)

MATLAB Installation, page 13

LSTK(LSIZE-1) = VSIZE-1

MSTK(LSIZE-1) = -1

NSTK(LSIZE-1) = -1

STKR(VSIZE-1) = 1.0D0

CALL PUTID(IDSTK(1,LSIZE), RAND)

LSTK(LSIZE) = VSIZE

MSTK(LSIZE) = 1

NSTK(LSIZE) = 1

FMT = 1

FLP(1) = 0

FLP(2) = 0

DDT = 0

RAN(2) = 0

PTZ = 0

PT = PTZ

ERR = 0

RIO = RTE

WIO = 0

IF (INIT .LT. 0) RETURN

C

90 CALL PARSE

IF (FUN .EQ. 1) CALL MATFN1

IF (FUN .EQ. 2) CALL MATFN2

IF (FUN .EQ. 3) CALL MATFN3

IF (FUN .EQ. 4) CALL MATFN4

IF (FUN .EQ. 5) CALL MATFN5

IF (FUN .EQ. 6) CALL MATFN6

IF (FUN .EQ. 21) CALL MATFN1

IF (FUN .NE. 99) GO TO 90

RETURN

END

MATLAB Installation, page 14

Typical file SYS (Nonstandard stuff in lower case):

C PROGRAM MAIN

call overflow-control

CALL MATLAB(0)

STOP

END

SUBROUTINE FILES(LUNIT,NAME)

INTEGER LUNIT,NAME(32)

C

C SYSTEM DEPENDENT ROUTINE TO ALLOCATE FILES

C LUNIT = LOGICAL UNIT NUMBER

C NAME = FILE NAME, 1 CHARACTER PER WORD

C

character*32 nam

c

c close exec, save, load and print files

if (lunit .lt. 0) then

close(unit=-lunit)

return

end if

c

c Fortran 77 internal file conversion from 32a1 to character*32

write(nam,'(32a1)') name

c

c formatted i/o for exec and print

if (lunit .gt. 2) open(unit=lunit,file=nam)

c

c unformatted i/o for save and load

if (lunit .le. 2) open(unit=lunit,file=nam,form='unformatted')

c

c rewind all except diary

if (lunit .ne. 8) rewind lunit

c

RETURN

END

SUBROUTINE SAVLOD(LUNIT,ID,M,N,IMG,JOB,XREAL,XIMAG)

INTEGER LUNIT,ID(4),M,N,IMG,JOB

DOUBLE PRECISION XREAL(1),XIMAG(1)

C

C IMPLEMENT SAVE AND LOAD

C LUNIT = LOGICAL UNIT NUMBER

C ID = NAME, FORMAT 4A1

C M, N = DIMENSIONS

C IMG = NONZERO IF XIMAG IS NONZERO

C JOB = 0 FOR SAVE

C = SPACE AVAILABLE FOR LOAD

C XREAL, XIMAG = REAL AND OPTIONAL IMAGINARY PARTS

C

MATLAB Installation, page 15

C THIS VERSION USES UNFORMATTED READ AND WRITE

C

IF (JOB .GT. 0) GO TO 20

C

C SAVE

10 WRITE(LUNIT) ID,M,N,IMG

DO 15 J = 1, N

K = (J-1)*M+1

L = J*M

WRITE(LUNIT) (XREAL(I),I=K,L)

IF (IMG .NE. 0) WRITE(LUNIT) (XIMAG(I),I=K,L)

15 CONTINUE

RETURN

C

C LOAD

20 READ(LUNIT,END=30) ID,M,N,IMG

IF (M*N .GT. JOB) GO TO 30

DO 25 J = 1, N

K = (J-1)*M+1

L = J*M

READ(LUNIT,END=30) (XREAL(I),I=K,L)

IF (IMG .NE. 0) READ(LUNIT,END=30) (XIMAG(I),I=K,L)

25 CONTINUE

RETURN

C

C END OF FILE

30 M = 0

N = 0

RETURN

END

SUBROUTINE FORMZ(LUNIT,X,Y)

DOUBLE PRECISION X,Y

C

C SYSTEM DEPENDENT ROUTINE TO PRINT WITH Z FORMAT

C

IF (Y .NE. 0.0D0) WRITE(LUNIT,10) X,Y

IF (Y .EQ. 0.0D0) WRITE(LUNIT,10) X

10 format(2z18)

RETURN

END

DOUBLE PRECISION FUNCTION FLOP(X)

DOUBLE PRECISION X

C SYSTEM DEPENDENT FUNCTION

C COUNT AND POSSIBLY CHOP EACH FLOATING POINT OPERATION

C FLP(1) IS FLOP COUNTER

C FLP(2) IS NUMBER OF PLACES TO BE CHOPPED

C

INTEGER SYM,SYN(4),BUF(256),CHAR,FLP(2),FIN,FUN,LHS,RHS,RAN(2)

COMMON /COM/ SYM,SYN,BUF,CHAR,FLP,FIN,FUN,LHS,RHS,RAN

MATLAB Installation, page 16

C

double precision mask(14),xx,mm

real mas(2,14)

logical lx(2),lm(2)

equivalence (lx(1),xx),(lm(1),mm)

equivalence (mask(1),mas(1))

data mas/

$ z'ffffffff',z'fff0ffff',

$ z'ffffffff',z'ff00ffff',

$ z'ffffffff',z'f000ffff',

$ z'ffffffff',z'0000ffff',

$ z'ffffffff',z'0000fff0',

$ z'ffffffff',z'0000ff00',

$ z'ffffffff',z'0000f000',

$ z'ffffffff',z'00000000',

$ z'fff0ffff',z'00000000',

$ z'ff00ffff',z'00000000',

$ z'f000ffff',z'00000000',

$ z'0000ffff',z'00000000',

$ z'0000fff0',z'00000000',

$ z'0000ff80',z'00000000'/

C

FLP(1) = FLP(1) + 1

K = FLP(2)

FLOP = X

IF (K .LE. 0) RETURN

FLOP = 0.0D0

IF (K .GE. 15) RETURN

XX = X

MM = MASK(K)

LX(1) = and(LX(1),LM(1))

LX(2) = and(LX(2),LM(2))

FLOP = XX

RETURN

END

SUBROUTINE XCHAR(BUF,K)

INTEGER BUF(1),K

C

C SYSTEM DEPENDENT ROUTINE TO HANDLE SPECIAL CHARACTERS

C

INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE

COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE

write(WTE,10) buf(1)

10 format(A1,' is not a MATLAB character.')

RETURN

END

SUBROUTINE USER(A,M,N,S,T)

DOUBLE PRECISION A(M,N),S,T

C

MATLAB Installation, page 17

INTEGER A3(9)

DATA A3 /-149,537,-27,-50,180,-9,-154,546,-25/

IF (A(1,1) .NE. 3.0D0) RETURN

DO 10 I = 1, 9

A(I,1) = A3(I)

10 CONTINUE

M = 3

N = 3

RETURN

END

SUBROUTINE PROMPT(PAUSE)

INTEGER PAUSE

C

C ISSUE MATLAB PROMPT WITH OPTIONAL PAUSE

C

INTEGER DDT,ERR,FMT,LCT(4),LIN(1024),LPT(6),RIO,WIO,RTE,WTE

COMMON /IOP/ DDT,ERR,FMT,LCT,LIN,LPT,RIO,WIO,RTE,WTE

WRITE(WTE,10)

IF (WIO .NE. 0) WRITE(WIO,10)

10 FORMAT(1X,/'<>')

IF (PAUSE .EQ. 1) READ(RTE,20) DUMMY

20 FORMAT(A1)

RETURN

END

SUBROUTINE PLOT(LUNIT,X,Y,N,P,K,BUF)

DOUBLE PRECISION X(N),Y(N),P(1)

INTEGER BUF(79)

C

C PLOT X VS. Y ON LUNIT

C IF K IS NONZERO, THEN P(1),...,P(K) ARE EXTRA PARAMETERS

C BUF IS WORK SPACE

C

DOUBLE PRECISION XMIN,YMIN,XMAX,YMAX,DY,DX,Y1,Y0

INTEGER AST,BLANK,H,W

DATA AST/1H*/,BLANK/1H /,H/20/,W/79/

C

C H = HEIGHT, W = WIDTH

C

XMIN = X(1)

XMAX = X(1)

YMIN = Y(1)

YMAX = Y(1)

DO 10 I = 1, N

XMIN = DMIN1(XMIN,X(I))

XMAX = DMAX1(XMAX,X(I))

YMIN = DMIN1(YMIN,Y(I))

YMAX = DMAX1(YMAX,Y(I))

10 CONTINUE

DX = XMAX - XMIN

MATLAB Installation, page 18

IF (DX .EQ. 0.0D0) DX = 1.0D0

DY = YMAX - YMIN

WRITE(LUNIT,35)

DO 40 L = 1, H

DO 20 J = 1, W

BUF(J) = BLANK

20 CONTINUE

Y1 = YMIN + (H-L+1)*DY/H

Y0 = YMIN + (H-L)*DY/H

JMAX = 1

DO 30 I = 1, N

IF (Y(I) .GT. Y1) GO TO 30

IF (L.NE.H .AND. Y(I).LE.Y0) GO TO 30

J = 1 + (W-1)*(X(I) - XMIN)/DX

BUF(J) = AST

JMAX = MAX0(JMAX,J)

30 CONTINUE

WRITE(LUNIT,35) (BUF(J),J=1,JMAX)

35 FORMAT(1X,79A1)

40 CONTINUE

RETURN

END

SUBROUTINE EDIT(BUF,N)

INTEGER BUF(N)

C

C CALLED AFTER INPUT OF A SINGLE BACKSLASH

C BUF CONTAINS PREVIOUS INPUT LINE, ONE CHAR PER WORD

C ENTER LOCAL EDITOR IF POSSIBLE

C

character*256 s

open(7,file='----')

write(7,10) (buf(i),i=1,n)

10 format(256a1)

close(7)

call system('edit ----')

open(7,file='----')

rewind 7

read(7,'(a)') s

close(7)

call system('remove ----')

n = 0

do 20 i = 1, 256

if (s(i:i) .ne. ' ') n = i

20 continue

read(s,10) (buf(i),i=1,n)

RETURN

END

Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/