Altair_8800_BASIC_Reference_Manual_1975 BASIC Manual 75

User Manual: BASIC Manual 75

Open the PDF directly: View PDF .
Page Count: 108 [warning: Documents this large are best viewed by clicking the View PDF Link!]

M!TS ALTA!R BASiC

REFERENCE MANUAL

1ab!e of Contents:

INTRODUCTION I

GETTING STARTED WITH BASIC 1

REFERENCE MATERIAL 23

APPENDICES 45

A) HOW TO LOAD BASIC 46

B) INITIALIZATION DIALOG 51

C) ERROR MESSAGES 53

D) SPACE HINTS 56

E) SPEED HINTS 58

F) DERIVED FUNCTIONS 59

G) SIMULATED MATH FUNCTIONS 60

H) CONVERTING BASIC PROGRAMS NOT

WRITTEN FOR THE ALTAIR 62

I) USING THE ACR INTERFACE 64

J) BASIC/MACHINE LANGUAGE INTERFACE 66

K) ASCII CHARACTER CODES 69

L) EXTENDED BASIC 71

M) BASIC TEXTS 73

@MITS, Inc., 1975

PRtNTED )N U.S.A. "Creative E!ectronics"

P.O. BOX 8636

ALBUQUERQUE. NEW MEXtCO 87108

ALM1R - ---- ——

Bd5ir

The following are additions and corrections to the ALTAIR BASIC REFERENCE

MANUAL. Be sure to read this over carefully before continuing.

1) If you are loading BASIC from paper tape, be sure your Serial I/O

board is strapped for eight data bits and no parity bit.

2) On page 53 in Appendix C, the meaning for an "OS" error should read:

Out of String Space. Allocate more string space by using

the "CLEAR" command with an argument (see page 42), and then

run your program again. If you cannot allocate more string

space, try using smaller strings or less string variables.

3) On page 42, under the "CLEAR" command, It is stated that "CLEAR" with

no argument sets the amount of string space to 200 bytes. This is in-

correct. "CLEAR" with no argument leaves the amount of string space

unchanged. When BASIC is brought up, the amount of string space is

initially set to 50 bytes.

4) On page 30, under the "DATA" statement, the sentence "IN THE 4K VERSION

OF BASIC, DATA STATEMENTS MUST BE THE FIRST STATEMENTS ON A LINE,"

should be changed to read, "IN THE 4K VERSION OF BASIC, A DATA STATE-

MENT MUST BE ALONE ON A LINE."

5) If you desire to use a terminal interfaced to the ALTAIR with a

Parallel I/O board as your system console, you should load from the

ACR interface (wired for address 6). Use the ACR load procedure de-

scribed in Appendix A, except that you should raise switches 15 § 13

when you start the boot. The Parallel I/O board must be strapped to

address 0.

6) If you get a checksum error while loading BASIC from a paper tape or a

cassette, you may be able to restart the boot loader at location 0 with

the appropriate sense switch settings. This depends on when the error

occurs. The boot loader is not written over until the last block of

BASIC is being read; which occurs during approximately the last two

feet of a paper tape, or the last 10 to 15 seconds of a cassette. If

the checksum error occurs during the reading of the last block of BASIC,

the boot will be overwritten and you will have to key it in again.

7) The number of nulls punched after a carriage return/line feed does not

need to be set >=3 for Teletypes or >=6 for 30 CPS paper tape terminals,

as described under the "NULL" command on page 23 of the BASIC manual.

In almost all cases, no extra nulls need be punched after a CR/LF on

Teletypes, and a setting of nulls to 3 should be sufficient for 30 CPS

paper tape terminals. If any problems occur when reading tape (the

first few characters of lines are lost), change the null setting to 1

for Teletypes and 4 for 30 CPS terminals.

8) If you have any problems loading BASIC, check to make sure that your

terminal interface board (SIO or PIO) is working properly. Key in the

appropriate echo program from below, and start it at location zero.

Each character typed should be typed or displayed on your terminal. If

this is not the case, first be sure that you are using the correct echo

program. If you are using the correct program, but it is not function-

ing properly, then most likely the interface board or the terminal is

not operating correctly.

Jn tAe /bZZoMtng program ZtsttMjs^ t^e MM/n&er to t^e Z-e/t t^e sZasTz

ts t^e oetaZ address and t^e TiMW^er to t&e rtjAt ^s t^e ocMZ. code /or t^at

address.

FOR REV 0 SERIAL I/O BOARDS WITHOUT THE STATUS BIT MODIFICATION

0/333 1 / QOQ 2 / 34b

3/040 4/313 5 / 000

b / 000 7 / 333 10 / 001

11 / 353 13 / 001 13 / 303

14 / 000 15 / 000

FOR REV 1 SERIAL I/O BOARDS (AND REV 0 MODIFIED BOARDS)

0 / 333

3 / 33E

b / 333

11 / 001

14 / 000

1 / 000

4 / 000

7 / 001

IB / 303

3 / 017

5 / 000

10 / 333

13 / 000

FOR PARALLEL 1/0 BOARDS

0 / 333

3 / 003

t= / 000

11 / 333

14 / 000

1 / 000

4 / 313

7 / 333

13 / 001

15 / 000

3 / 34b

5 / 000

10 / 001

13 / 303

For those of you with the book, MY COMPUTER LIKES ME when i speak in

BASIC, by Bob Albrecht, the following information may be helpful.

1) ALTAIR BASIC uses "NEW" instead of "SCR" to delete the current

program.

2) Use Control-C to stop execution of a program. Use a carriage-

return to stop a program at an "INPUT" statement.

3) You don't need an "END" statement at the end of a BASIC program.

Before a computer can perform any useful function, it must be "told"

what to do. Unfortunately, at this time, computers are not capable of

understanding English or any other "human" language. This is primarily

because our languages are rich with ambiguities and implied meanings.

The computer must be told precise instructions and the exact sequence of

operations to be performed in order to accomplish any specific task.

Therefore, in order to facilitate human communication with a computer,

programming languages have been developed.

ALTAIR BASIC* is a programming language both easily understood and

simple to use. It serves as an excellent "tool" for applications in

areas such as business, science and education. Mith only a few hours of

using BASIC, you will find that you can already write programs with an

ease that few other computer languages can duplicate.

Originally developed at Dartmouth University, BASIC language has

found wide acceptance in the computer field. Although it is one of the

simplest computer languages to use, it is very powerful. BASIC uses a

small set of common English words as its "commands". Designed specifi-

cally as an "interactive" language, you can give a command such as

"PRINT 2 + 2", and ALTAIR BASIC will immediately reply with "4". It

isn't necessary to submit a card deck with your program on it and then

wait hours for the results. Instead the full power of the ALTAIR is "at

your fingertips".

Generally, if the computer does not solve a particular problem the

way you expected it to, there is a "Bug" or error in your program, or

else there is an error in the data which the program used to calculate

its answer. If you encounter any errors in BASIC itself, please let us

know and we'll see that it's corrected. Write a letter to us containing

the following information:

1) System Configuration

2) Version of BASIC

3) A detailed description of the error

Include all pertinent information

such as a listing of the program in

which the error occurred, the data

placed into the program and BASIC'S

printout.

All of the information listed above will be necessary in order to pro-

perly evaluate the problem and correct it as quickly as possible. We

wish to maintain as high a level of quality as possible with all of our

ALTAIR software.

* BASIC ^s g reg-z^gre^ trademark o/ Par^moM^T: Z/n^grst^z/.

Me hope that you enjoy ALTAIR BASIC, and are successful in using it

to solve all of your programming needs.

In order to maintain a maximum quality level in our documentation,

we will be continuously revising this manual. If you have any sugges-

tions on how we can improve it, please let us know.

If you are already familiar with BASIC programming, the following

section may be skipped. Turn directly to the Reference Material on

page 22.

M9TE; MZTF 4LT4.Z7? R4RTC ts at?at^aMe under ^oense or pMrcTxzse

agreements. 6*op$/tn<y or ot&erMtse dtstrt&Mt^ng MPTF so/tMare OMt-

stde t^ze terms o/ SMc^! an agreement may &e a v^oZat^cn of cop^rtg-^zt

^aMs or t&e agreement ^tseZf.

If any immediate problems with MITS software are encountered, feel

free to give us a call at (505) 265-7553. The Software Department

is at Ext. 3; and the joint authors of the ALTAiR BASIC Interpreter,

Bill Gates, Paul Allen and Monte Davidoff, will be glad to assist you.

'mtmrEE)

This section is not intended to be a detailed course in BASIC pro-

gramming. It will, however, serve as an excellent introduction for those

of you unfamiliar with the language.

The text here will introduce the primary concepts and uses of BASIC

enough to get you started writing programs. For further reading sugges-

tions, see Appendix M.

If your ALTAIR does not have BASIC loaded and running, follow the

procedures in Appendices A 5 B to bring it up.

We recommend that you try each example in this section as it is pre-

sented. This will enhance your "feel" for BASIC and how it is used.

Once your I/O device has typed " OK ", you are ready to use ALTAIR

BASIC.

M3TE; commands to ^LTAZT? BASTC shouM end zJtth a carriage

return. The carriage return teZZs BASTC that z/OM haue /Yntshed'

tz/ptng the command. Jf z/OM ma^e a tz/ptng error, t^/pe a &ac&-

arroM ^ J, z^s^aHz/ sht/t/O, or an zander Ztne to e^^mtnate the

Zast character. Repeated use o/ " " e^m^nate prevtOMS

characters. i4n at-stgn ( ^ ^ MtZ.^ e^tm^nate the entire Ztne

that z/OM are tz/p^ng.

Now, try typing in the following:

PRINT 10-4 (end with carriage,return)

ALTAIR BASIC will immediately print:

The print statement you typed in was executed as soon as you hit the

carriage return key. BASIC evaluated the formula after the "PRINT" and

then typed out its value, in this case 6.

Now try typing in this:

PRINT 1/2,3*10 f"*" means mM^pZz/, '7" means d^dej

ALTAIR BASIC will print:

.5 3D

As you can see, ALTAIR BASIC can do division and multiplication as

well as subtraction. Note how a " , " (comma) was used in the print com-

mand to print two values instead of just one. The comma divides the 72

character line into 5 columns, each 14 characters wide. The last two of

the positions on the line are not used. The result is a " , " causes

BASIC to skip to the next 14 column field on the terminal, where the

value 30 was printed.

Commands such as the "PRINT" statements you have just typed in are

called Direct Commands. There is another type of command called an In-

direct Command. Every Indirect command begins with a Line Number. A

Line Number is any integer from 0 to 65529.

Try typing in the following lines:

10 PRINT 2+3

20 PRINT 2-3

A sequence of Indirect Commands is called a "Program". Instead of

executing indirect statements immediately, ALTAIR BASIC saves Indirect

Commands in the ALTAIR's memory. When you type in RUN , BASIC will

execute the lowest numbered indirect statement that has been typed in

first, then the next highest, etc. for as many as were typed in.

Suppose we type in RUN now:

RUN

ALTAIR BASIC will type out:

-1

In the example above, we typed in line 10 first and line 20 second.

However, it makes no difference in what order you type in indirect state-

ments. BASIC always puts them into correct numerical order according to

the Line Number.

If we want a listing of the complete program currently in memory,

we type in LIST . Type this in:

LIST

ALTAIR BASIC will reply with:

10 PRINT B+3

B0 PRINT E-3

Sometimes it is desirable to delete a line of a program altogether.

This is accomplished by typing the Line Number of the line we wish to

delete, followed only by a carriage return.

Type in the following:

LIST

ALTAIR BASIC will reply with:

BO PRINT E-3

We have now deleted line 10 from the program. There is no way to

get it back. To insert a new line 10, just type in 10 followed by the

statement we want BASIC to execute.

Type in the following:

10 PRINT 2*3

LIST

ALTAIR BASIC will reply with:

10 PRINT E*3

B0 PRINT B-3

There is an easier way to replace line 10 than deleting it and then

inserting a new line. You can do this by just typing the new line 10 and

hitting the carriage return. BASIC throws away the old line 10 and re-

places it with the new one.

Type in the following:

10 PRINT 3-3

LIST

ALTAIR BASIC will reply with:

10 PRINT 3-3

E0 PRINT B-3

It is not recommended that lines be numbered consecutively. It may

become necessary to insert a new line between two existing lines. An in-

crement of 10 between line numbers is generally sufficient.

If you want to erase the complete program currently stored in memory,

type in " NEW ". If you are finished running one program and are about

to read in a new one, be sure to type in " NEW " first. This should be

done in order to prevent a mixture of the old and new programs.

Type in the following:

NEW

ALTAIR BASIC will reply with:

Now type in:

LIST

ALTAIR BASIC will reply with:

Often it is desirable to include text along with answers that are

printed out, in order to explain the meaning of the numbers.

Type in the following:

PRINT "ONE THIRD IS EQUAL TO",1/3

ALTAIR BASIC will reply with:

ONE THIRD IS EdUAL TO .333333

As explained earlier, including a " , " in a print statement causes

it to space over to the next fourteen Column field before the value fol-

lowing the " , " is printed.

If we use a " ; " instead of a comma, the value next will be printed

immediately following the previous value.

M^m&ers are a^Maz/s printed Mtth at Zeast owe tratZtMg space,

/tm/ text to printed ts a^zjaz/s to &e enclosed w douMe quotes.

Try the following examples:

A) PRINT "ONE THIRD IS EQUAL TO";1/3

ONE THIRD IS Et2UAL TO .333333

B) PRINT 1,2,3

15 3

C) PRINT 1;2;3

13 3

D) PRINT -l;2;-3

-1 B -3

We will digress for a moment to explain the format of numbers in

ALTAIR BASIC. Numbers are stored internally to over six digits of ac-

curacy. When a number is printed, only six digits are shown. Every

number may also have an exponent (a power of ten scaling factor).

The largest number that may be represented in ALTAIR BASIC is

1.70141*1038, while the smallest positive number is 2.93874*10*39.

When a number is printed, the following rules are used to determine

the exact format:

1) If the number is negative, a minus sign (-) is printed.

If the number is positive, a space is printed.

2) If the absolute value of the number is an integer in the

range 0 to 999999, it is printed as an integer.

3) If the absolute value of the number is greater than or

equal to .1 and less than or equal to 999999, it is printed

in fixed point notation, with no exponent.

4) If the number does not fall under categories 2 or 3,

scientific notation is used.

Scientific notation is formatted as follows: SX.XXXXXESTT .

(each X being some integer 0 to 9)

The leading "S" is the sign of the number, a space for a

positive number and a " - " for a negative one. One non-

zero digit is printed before the decimal point. This is

followed by the decimal point and then the other five digits

of the mantissa. An "E" is then printed (for exponent),

followed by the sign (S) of the exponent; then the two

digits (TT) of the exponent itself. Leading zeroes are

never printed; i.e. the digit before the decimal is never

zero. Also, trailing zeroes are never printed. If there

is only one digit to print after all trailing zeroes are

suppressed, no decimal point is printed. The exponent

sign will be " + " for positive and " - " for negative.

Two digits of the exponent are always printed; that is

zeroes are not suppressed in the exponent field. The

value of any number expressed thus is the number to the

left of the "E" times 10 raised to the power of the number

to the right of the "E".

No matter what format is used, a space is always printed following

a number. The 8K version of BASIC checks to see if the entire number

will fit on the current line. If not, a carriage return/line feed is

executed before printing the number.

The following are examples of various numbers and the output format

ALTAIR BASIC will place them into:

NUMBER

-1

6523

-23.460

1E20

-12.3456E-7

1.234S67E-10

1000000

999999

.01

.000123

OUTPUT FORMAT

-I

L5B3

-33.4b

1E+B0

-l.B345t,E-0b

1.B3457E-10

lE+Ob

1E-Q3

1-B3E-04

A number input from the terminal or a numeric constant used in a

BASIC program may have as many digits as desired, up to the maximum length

of a line (72 characters). Howevbr, only the first 7 digits are signifi-

cant, and the seventh digit is rounded up.

PRINT 1.2345678901234567890

1.E3457

The following is an example of a program that reads a value from the

terminal and uses that value to calculate and print a result:

10 INPUT R

20 PRINT 3.14159*R*R

RUN

7 10

314.151

Here's what's happening. When BASIC encounters the input statement,

it types a question mark (?) on the terminal and then waits for you to

type in a number. When you do (in the above example 10 was typed), execu-

tion continues with the next statement in the program after the variable

(R) has been set (in this case to 10). In the above example, line 20

would now be executed. When the formula after the PRINT statement is

evaluated, the value 10 is substituted for the variable R each time R ap-

pears in the formula. Therefore, the formula becomes 3.14159*10*10, or

314.159.

If you haven't already guessed, what the program above actually does

is to calculate the area of a circle with the radius "R".

11* wo wanted to calculate the area of various clrclcs, wc could keep

ru-running the program over each time for each succcssivc circle. But,

there's an easier way to do it simply by adding another line to the pro-

gram as follows:

30 GOTO 10

RUN

? 10

314.151

? 3

ER.E743

? 4.7

L1.3T77

By putting a " GOTO " statement on the end of our program, we have

caused it to go back to line 10 after it prints each answer for the suc-

cessive circles. This could have gone on indefinitely, but we decided

to stop after calculating the area for three circles. This was accom-

plished by typing a carriage return to the input statement (thus a blank

M32TF; Typing a carriage return to an tnpMt statement tn tTze 4X

version of BASTC Mt^ ea^se a 5W error (see Re/erenoe AfatertaZJ.

The letter "R" in the program we just used was termed a "variable".

A variable name can be any alphabetic character and may be followed by

any alphanumeric character.

In the 4K version of BASIC, the second character must be numeric

or omitted. In the 8K version of BASIC, any alphanumeric characters

after the first two are ignored. An alphanumeric character is any let-

ter (A-Z) or any number (0-9).

Below are some examples of legal and illegal variable names:

line).

LEGAL ILLEGAL

IN 4K VERSION

Z1 % (1st character must be alphabetic)

Z1A (variable name too long)

QR (2nd character must be numeric)

IN 8K VERSION

PSTG$

COUNT

TO (variable names cannot be reserved

words)

RG0TO (variable names cannot contain

reserved words)

The words used as BASIC statements are "reserved" for this specific

purpose. You cannot use these words as variable names or inside of any

variable name. For instance, "FEND" would be illegal because "END" is a

reserved word.

The following is a list of the reserved words in ALTAIR BASIC:

4K RESERVED WORDS

ABS CLEAR DATA DIM END FOR GOSUB GOTO IF INPUT

INT LET LIST NEW NEXT PRINT READ REM RESTORE

RETURN RND RUN SGN SIN SQR STEP STOP TAB( THEN

TO USR

8K RESERVED WORDS INCLUDE ALL THOSE ABOVE, AND IN ADDITION

ASC AND ATN CHR$ CLOAD CONT COS CSAVE DEF EXP

FN FRE INP LEFT$ LEN LOG MID$ NULL ON OR NOT

OUT PEEK POKE POS RIGHT$ SPC( STR$ TAN VAL WAIT

Remember, in the 4K version of BASIC variable names are only a letter

or a letter followed by a number. Therefore, there is no possibility of

a conflict with a reserved word.

Besides having values assigned to variables with an input statement,

you can also set the value of a variable with a LET or assignment state-

ment.

Try the following examples:

A=5

PRINTA,A*2

5 10

LETZ=7

PRINT Z,Z-A

7 B

As can be seen from the examples, the "LET" is optional in an assign-

ment statement.

BASIC "remembers" the values that have been assigned to variables

using this type of statement. This "remembering" process uses space in

the ALTAIR's memory to store the data.

The values of variables are thrown away and the space in memory

used to store them is released when one of four things occur:

1) A new line is typed into the program or an old

line is deleted

2) A CLEAR command is typed in

3) A RUN command is typed in

4) NEW is typed in

Another important fact is that if a variable is encountered in a

formula before it is assigned a value, it is automatically assigned the

value zero. Zero is then substituted as the value of the variable in

the particular formula. Try the example below:

PRINT Q,Q+2,Q*2

0 2 0

Another statement is the REM statement. REM is short for remark.

This statement is used to insert comments or notes into a program. When

BASIC encounters a REM statement the rest of the line is ignored.

This serves mainly as an aid for the .programmer himself, and serves

no useful function as far as the operation of the program in solving a

particular problem.

Suppose we wanted to write a program to check if a number is zero

or not. With the statements we've gone over so far this could not be

done. What is needed is a statement which can be used to conditionally

branch to another statement. The "IF-THEN" statement does just that.

Try typing in the following program: (remember, type NEW first)

10 INPUT B

20 IF B=0 THEN 50

30 PRINT "NON-ZERO"

40 GOTO 10

50 PRINT "ZERO"

60 GOTO 10

When this program is typed into the ALTAIR and run, it will ask for

a value for B. Type any value you wish in. The ALTAIR will then come to

the "IF" statement. Between the "IF" and the "THEN" portion of the state-

ment there are two expressions separated by a relation.

A relation is one of the following six symbols:

RELATION MEANING

EQUAL TO

GREATER THAN

LESS THAN

NOT EQUAL TO

LESS THAN OR EQUAL TO

GREATER THAN OR EQUAL TO

The IF statement is either true or false, depending upon whether the

two expressions satisfy the relation or not. For example, in the pro-

gram we just did, if 0 was typed in for B the IF statement would be true

because 0=0. In this case, since the number after the THEN is 50, execu-

tion of the program would continue at line 50. Therefore, "ZERO" would

be printed and then the program would jump back to line 10 (because of

the GOTO statement in line 60).

Suppose a 1 was typed in for B. Since 1=0 is false, the IF state-

ment would be false and the program would continue execution with the

next line. Therefore, "NON-ZERO" would be printed and the GOTO in line

40 would send the program back to line 10.

Now try the following program for comparing two numbers:

10 INPUT A,B

20 IF A<=B THEN 50

30 PRINT "A IS BIGGER"

40 GOTO 10

50 IF A<B THEN 80

60 PRINT "THEY ARE THE SAME"

70 GOTO 10

80 PRINT "B IS BIGGER"

90 GOTO 10

When this program is run, line 10 will input two numbers from the

terminal. At line 20, if A is greater than B, A<=B will be false. This

will cause the next statement to be executed, printing "A IS BIGGER" and

then line 40 sends the computer back to line 10 to begin again.

At line 20, if A has the same value as B, A<=B is true so we go to

line 50. At line 50, since A has the same value as B, A<B is false;

therefore, we go to the following statement and print "THEY ARE THE SAME"

Then line 70 sends us back to the beginning again.

At line 20, if A is smaller than B, A<=B is true so we go to line 50

At line 50, A<B will be true so we then go to line 80. "B IS BIGGER" is

then printed and again we go back to the beginning.

Try running the last two programs several times. It may make it

easier to understand if you try writing your own program at this time

using the IF-THEN statement. Actually trying programs of your own is

the quickest and easiest way to understand how BASIC works. Remember,

to stop these programs just give a carriage return to the input state-

ment.

One advantage of computers is their ability to perform repetitive

tasks. Let's take a closer look and see how this works.

Suppose we want a table of square roots from 1 to 10. The BASIC

function for square root is "SQR"; the form being SQR(X), X being the

number you wish the square root calculated from. We could write the pro-

gram as follows:

10 PRINT 1,SQR(1)

20 PRINT 2,SQR(2)

30 PRINT 3,SQR(3)

40 PRINT 4,SQR(4)

50 PRINT 5,SQR(5)

60 PRINT 6,SQR(6)

70 PRINT 7,SQR(7)

80 PRINT 8,SQR(8)

90 PRINT 9,SQR(9)

100 PRINT 10,SQR(10)

This program will do the job; however, it is terribly inefficient.

We can improve the program tremendously by using the IF statement just

introduced as follows:

10 N=1

20 PRINT N,SQR(N)

30 N=N+1

40 IF N<=10 THEN 20

When this program is run, its output will look exactly like that of

the 10 statement program above it. Let's look at how it works.

At line 10 we have a LET statement which sets the value of the vari-

able N at 1. At line 20 we print N and the square root of N using its

current value. It thus becomes 20 PRINT 1,SQR(1), and this calculation

is printed out.

At line 30 we use what will appear at first to be a rather unusual

LET statement. Mathematically, the statement N=N+1 is nonsense. However,

the important thing to remember is that in a LET statement, the symbol

" = " does not signify equality. In this case " = " means "to be replaced

with". All the statement does is to take the current value of N and add

1 to it. Thus, after the first time through line 30, N becomes 2.

At line 40, since N now equals 2, N<=10 is true so the THEN portion

branches us back to line 20, with N now at a value of 2.

The overall result is that lines 20 through 40 are repeated, each

time adding 1 to the value of N. When N finally equals 10 at line 20,

the next line will increment it to 11. This results in a false state-

ment at line 40, and since there are no further statements to the pro-

gram it stops.

This technique is referred to as "looping" or "iteration". Since

it is used quite extensively in programming, there are special BASIC

statements for using it. We can show these with the following pro-

gram.

10 FOR N=1 TO 10

20 PRINT N,SQR(N)

30 NEXT N

The output of the program listed above will be exactly the same as

the previous two programs.

At line 10, N is set to equal 1. Line 20 causes the value of N and

the square root of N to be printed. At line 30 we see a new type of

statement. The "NEXT N" statement causes one to be added to N, and then

if N<=10 we go back to the statement following the "FOR" statement. The

overall operation then is the same as with the previous program.

Notice that the variable following the "FOR" is exactly the same as

the variable after the "NEXT". There is nothing special about the N in

this case. Any variable could be used, as long as they are the same in

both the "FOR" and the "NEXT" statements. For instance, "Zl" could be

substituted everywhere there is an "N" in the above program and it would

function exactly the same.

Suppose we wanted to print a table of square roots from 10 to 20,

only counting by two's. The following program would perform this task:

10N=10

20 PRINT N,SQR(N)

30 N=N+2

40 IF N<=20 THEN 20

Note the similar structure between this program and the one listed

on page 12 for printing square roots for the numbers 1 to 10. This pro-

gram can also be written using the "FOR" loop just introduced.

10 FOR N=10 TO 20 STEP 2

20 PRINT N,SQR(N)

30 NEXT N

Notice that the only major difference between this program and the

previous one using "FOR" loops is the addition of the "STEP 2" clause.

This tells BASIC to add 2 to N each time, instead of 1 as in the

previous program. If no "STEP" is given in a "FOR" statement, BASIC as-

sumes that one is to be added each time. The "STEP" can be followed by

any expression.

Suppose we wanted to count backwards from 10 to 1. A program for

doing this would be as follows:

10 1=10

20 PRINT I

30 1=1-1

40 IF I>=1 THEN 20

Notice that we are now checking to see that I is greater than or

equal to the final value. The reason is that we are now counting by a

negative number. In the previous examples it was the opposite, so we

were checking for a variable less than or equal to the final value.

The "STEP" statement previously shown can also be used with negative

numbers to accomplish this same purpose. This can be done using the same

format as in the other program, as follows:

10 FOR 1=10 TO 1 STEP -1

20 PRINT I

30 NEXT I

"FOR" loops can also be "nested". An example of this procedure fol-

lows:

10 FOR 1=1 TO 5

20 FOR J=1 TO 3

30 PRINT I,J

40 NEXT J

50 NEXT I

Notice that the "NEXT J" comes before the "NEXT I". This is because

the J-loop is inside of the 1-loop. The following program is incorrect;

run it and see what happens.

10 FOR 1=1 TO 5

20 FOR J=1 TO 3

30 PRINT I,J

40 NEXT I

50 NEXT J

It does not work because when the "NEXT I" is encountered, all know-

ledge of the J-loop is lost. This happens because the J-loop is "inside"

of the 1-loop.

It is often convenient to be able to select any element in a table

of numbers. BASIC allows this to be done through the use of matrices.

A matrix is a table of numbers. The name of this table, called the

matrix name, is any legal variable name, "A" for example. The matrix

name "A" is distinct and separate from the simple variable "A", and you

could use both in the same program.

To select an element of the table, we subscript "A" : that is to

select the I'th element, we enclose I in parenthesis "(I)" and then fol-

low "A" by this subscript. Therefore, "A(I)" is the I'th element in the

matrix "A".

M3TF; JTn tMs section of t&e manual Me zJtZZ &e concerned h^t?!

one-dtmenstonaZ matrices (Fee Reference A/atertaZJ

"A(I)" is only one element of matrix A, and BASIC must be told how

much space to allocate for the entire matrix.

This is done with a "DIM" statement, using the format "DIM A(15)".

In this case, we have reserved space for the matrix index "I" to go from

0 to 15. Matrix subscripts always start at 0; therefore, in the above

example, we have allowed for 16 numbers in matrix A.

If "A(I)" is used in a program before it has been dimensioned, BASIC

reserves space for 11 elements (0 through 10).

As an example of how matrices are used, try the following program

to sort a list of 8 numbers with you picking the numbers to be sorted.

10 DIM A(8)

20 FOR 1=1 TO 8

30 INPUT A(I)

50 NEXT I

70F=0

80 FOR 1=1 TO 7

90 IF A(I)<=A(I+1) THEN 140

100T=A(I)

110 A(I)= A(I+1)

120A(I+1)=T

130 F=1

140 NEXT I

150 IF F=1 THEN 70

160 FOR 1=1 TO 8

170 PRINT A(I),

180 NEXT I

When line 10 is executed, BASIC sets aside space for 9 numeric values,

A(0) through A(8). Lines 20 through 50 get the unsorted list from the

user. The sorting itself is done by going through the list of numbers and

upon finding any two that are not in order, we switch them. "F" is used

to indicate if any switches were done. If any were done, line 150 tells

BASIC to go back and check some more.

If we did not switch any numbers, or after they are all in order,

lines 160 through 180 will print out the sorted list. Note that a sub-

script can be any expression.

Another useful pair of statements are "GOSUB" and "RETURN". If you

have a program that performs the same action in several different places,

you could duplicate the same statements for the action in each place with-

in the program.

The "GOSUB"-"RETURN" statements can be used to avoid this duplication.

When a "GOSUB" is encountered, BASIC branches to the line whose number fol-

lows the "GOSUB". However, BASIC remembers where it was in the program

before it branched. When the "RETURN" statement is encountered, BASIC

goes back to the first statement following the last "GOSUB" that was exe-

cuted. Observe the following program.

10 PRINT "WHAT IS THE NUMBER";

30 GOSUB 100

40T=N

50 PRINT "WHAT IS THE SECOND NUMBER";

70 GOSUB 100

80 PRINT "THE SUM OF THE TWO NUMBERS IS",T+N

90 STOP

100 INPUT N

110 IF N = INT(N) THEN 140

120 PRINT "SORRY, NUMBER MUST BE AN INTEGER. TRY AGAIN."

130 GOTO 100

140 RETURN

What this program does is to ask for two numbers which must be inte-

gers, and then prints the sum of the two. The subroutine in this pro-

gram is lines 100 to 130. The subroutine asks for a number, and if it

is not an integer, asks for a number again. It will continue to ask until

an integer value is typed in.

The main program prints " hJHAT IS THE NUMBER ", and then calls the

subroutine to get the value of the number into N. When the subroutine

returns (to line 40), the value input is saved in the variable T. This

is done so that when the subroutine is called a second time, the value

of the first number will not be lost.

" hiHAT IS THE SECOND NUMBER " is then printed, and the second value

is entered when the subroutine is again called.

When the subroutine returns the second time, " THE SUM OF THE Th<0

NUMBERS IS " is printed, followed by the value of their sum. T contains

the value of the first number that was entered and N contains the value

of the second number.

The next statement in the program is a "STOP" statement. This causes

the program to stop execution at line 90. If the "STOP" statement was not

included in the program, we would "fall into" the subroutine at line 100.

This is undesirable because we would be asked to input another number. If

we did, the subroutine would try to return; and since there was no "GOSUB"

which called the subroutine, an RG error would occur. Each "GOSUB" exe-

cuted in a program should have a matching "RETURN" executed later, and the

opposite applies, i.e. a "RETURN" should be encountered only if it is

part of a subroutine which has been called by a "GOSUB".

Either "STOP" or "END" can be used to separate a program from its

subroutines. In the 4K version of BASIC, there is no difference between

the "STOP" and the "END". In the 8K version, "STOP" will print a mes-

sage saying at what line the "STOP" was encountered.

Suppose you had to enter numbers to your program that didn't change

each time the program was run, but you would like it to be easy to change

them if necessary. BASIC contains special statements for this purpose,

called the "READ" and "DATA" statements.

Consider the following program:

10 PRINT "GUESS A NUMBER";

20 INPUT G

30 READ D

40 IF D=-999999 THEN 90

50 IF DoG THEN 30

60 PRINT "YOU ARE CORRECT"

70 END

90 PRINT "BAD GUESS, TRY AGAIN."

95 RESTORE

100 GOTO 10

110 DATA 1,393,-39,28,391,-8,0,3.14,90

120 DATA 89,5,10,15,-34,-999999

This is what happens when this program is run. When the "READ"

statement is encountered, the effect is the same as an INPUT statement.

But, instead of getting a number from the terminal, a number is read

from the "DATA" statements.

The first time a number is needed for a READ, the first number in

the first DATA statement is returned. The second time one is needed,

the second number in the first DATA statement is returned. When the en-

tire contents of the first DATA statement have been read in this manner,

the second DATA statement will then be used. DATA is always read se-

quentially in this manner, and there may be any number of DATA statements

in your program.

The purpose of this program is to play a little game in which you

try to guess one of the numbers contained in the DATA statements. For

each guess that is typed in, we read through all of the numbers in the

DATA statements until we find one that matches the guess.

If more values are read than there are numbers in the DATA state-

ments, an out of data (OD) error occurs. That is why in line 40 we check

to see if -999999 was read. This is not one of the numbers to be matched,

but is used as a flag to indicate that all of the data (possible correct

guesses) has been read. Therefore, if -999999 was read, we know that the

guess given was incorrect.

Before going back to line 10 for another guess, we need to make the

READ'S begin with the first piece of data again. This is the function of

the "RESTORE". After the RESTORE is encountered, the next piece of data

read will be the first piece in the first DATA statement again.

DATA statements may be placed anywhere within the program. Only

READ statements make use of the DATA statements in a program, and any

other time they are encountered during program execution they will be

ignored.

TRE FCLLCWiWC JT^FOFAMyJOF APPLIES TO 2WF VERSION

OF BASIC (WLY

A list of characters is referred to as a "String". MITS, ALTAIR,

and THIS IS A TEST are all strings. Like numeric variables, string

variables can be assigned specific values. String variables are distin-

guished from numeric variables by a "$" after the variable name.

For example, try the following:

A$="ALTAIR8800"

PRINT A$

ALTAIR aaoo

In this example, we set the string variable A$ to the string value

"ALTAIR 8800". Note that we also enclosed the character string to be as-

signed to A$ in quotes.

Now that we have set A$ to a string value, we can find out what the

length of this value is (the number of characters it contains). We do

this as follows:

PRINT LEN(A$),LEN("MITS")

11 4

The "LBN" function returns an integer equal to the number of chara-

cters in a string.

The number of characters in a string expression may range from 0 to

255. A string which contains 0 characters is called the "NULL" string.

Before a string variable is set to a value in the program, it is initial-

ized to the null string. Printing a null string on the terminal will

cause no characters to be printed, and the print head or cursor will not

be advanced to the next column. Try the following:

PRINT LEN(Q$);Q$;3

Q 3

Another way to create the null string is: Q$=""

Setting a string variable to the null string can be used to free up

the string space used by a non-null string variable.

Often it is desirable to access parts of a string and manipulate

them. Now that we have set A$ to "ALTAIR 8800", we might want to print

out only the first six characters of A$. We would do so like this:

PRINT LEFT$(A$,6)

ALTAIR

"LEFT$" is a string function which returns a string composed of the

leftmost N characters of its string argument. Here's another example:

FOR N=1 TO LEN(A$):PRINT LEFT$(A$,N):NEXT N

ALT

ALTA

ALTAI

ALTAIR

ALTAIR 5

ALTAIR 66

ALTAIR 660

ALTAIR 6600

Since A$ has 11 characters, this loop will be executed with N=l,2,

3,...,10,11. The first time through only the first chatacter will be

printed, the second time the first two characters will be printed, etc.

There is another string function called "RIGHT$y which returns the

right N characters from a string expression. Try substituting "iRlGHT$"

for "LEFT$" in the previous example and see what happens.

There is also a string function which allows us to take characters

from the middle of a string. Try the following:

FOR N=1 TO LEN(A$):PRINT MID$(A$,N):NEXT N

ALTAIR 6600

LTAIR 6600

TAIR 6600

AIR 6600

IR 6600

R 6600

6600

600

"MID$" returns a string starting at the Nth position of A$ to the

end (last character) of A$. The first position of the string is posi-

tion 1 and the last possible position of a string is position 255.

Very often it is desirable to extract only the Nth character from

a string. This can be done by calling MID$ with three arguments. The

third argument specifies the number of characters to return.

For example:

FOR N=1 TO LEN(A$):PRINT MID$(A$,N,1),MID$(A$,N,2):NEXT N

A AL

L LT

T fA

A AI

1 IR

R R

6 66

6 60

0 00

0 0

See the Reference Material for more details on the workings of

"LEFT$", "RIGHT$" and "MID$".

Strings may also be concatenated (put or joined together) through

the use of the "+" operator. Try the following:

B$="MITS"+" "+A$

PRINT B$

NITS ALTAIR 6600

Concatenation is especially useful if you wish to take a string apart

and then put it back together with slight modifications. For instance:

C$=LEFT$(B$,4)+"-"+MID$(B$,6,6)+"-"+RIGHT$(B$,4)

PRINT C$

HITS-ALTAIR-6600

Sometimes it is desirable to convert a number to its string repre-

sentation and vice-versa. "VAL" and "STR$" perform these functions.

Try the following:

STRING$="567.8"

PRINT VAL(STRING$)

5L7.6

STRING$=STR$(3.1415)

PRINT STRING$,LEFT$(STRING$,5)

3-1415 3-14

"STR$" can be used to perform formatted I/O on numbers. You can

convert a number to a string and then use LEFT$, RIGHT$, MID$ and con-

catenation to reformat the number as desired.

"STR$" can also be used to conveniently find out how many print

columns a number will take. For example:

PRINT LEN(STR$(3.157))

If you have an application where a user is typing in a question such

as "WHAT IS THE VOLUME OF A CYLINDER OF RADIUS 5.36 FEET, OF HEIGHT 5.1

FEET?" you can use "VAL" to extract the numeric values 5.36 and 5.1 from

the question. For further functions "CHR$" and "ASC" see Appendix K.

The following program sorts a list of string data and prints out

the sorted list. This program is very similar to the one given earlier

for sorting a numeric list.

100 DIM A$(15):REM ALLOCATE SPACE FOR STRING MATRIX

110 FOR 1=1 TO 15:READ A$(I):NEXT I:REM READ IN STRINGS

120 F=0:I=1:REM SET EXCHANGE FLAG TO ZERO AND SUBSCRIPT TO 1

130 IF A$(I)<=A$(I+1) THEN 180:REM DON'T EXCHANGE IF ELEMENTS

IN ORDER

140 T$=A$(I+1):REM USE T$ TO SAVE A$(I+1)

150 A$(I+1)=A$(I):REM EXCHANGE TWO CONSECUTIVE ELEMENTS

160A$(I)=T$

170 F=1:REM FLAG THAT WE EXCHANGED TWO ELEMENTS

180 1=1+1: IF I<15 GOTO 130

185 REM ONCE WE HAVE MADE A PASS THRU ALL ELEMENTS, CHECK

187 REM TO SEE IF WE EXCHANGED ANY. IF NOT, DONE SORTING.

190 IF F THEN 120:REM EQUIVALENT TO IF F<>0 THEN 120

200 FOR 1=1 TO 15:PRINT A$(I):NEXT I: REM PRINT SORTED LIST

210 REM STRING DATA FOLLOWS

220 DATA APPLE,DOG,CAT,MITS,ALTAIR,RANDOM

230 DATA MONDAY,"***ANSWER***"," FOO"

240 DATA COMPUTER, FOO,ELP,MILWAUKEE,SEATTLE,ALBUQUERQUE

B451C LAfVEU^EE

COMMANDS

A command is usually given after BASIC has typed OK. This is called

the "Command Level". Commands may be used as program statements. Certain

commands, such as LIST, NEW and CLOAD will terminate program execution

when they finish.

NAME EXAMPLE PURPOSE/USE

CLEAR *(SEE PAGE 42 FOR EXAMPLES AND EXPLANATION)

LIST LIST Lists current program

LIST 100 optionally starting at specified line.

List can be control-C'd (BASIC will

finish listing the current line)

NULL NULL 3 (Null command only in 8K version, but

paragraph applicable to 4K version also)

Sets the number of null (ASCII 0) charac-

ters printed after a carriage return/line

feed. The number of nulls printed may

be set from 0 to 71. This is a must for

hardcopy terminals that require a delay

after a CRLFf It is necessary to set the

number of nulls typed on CRLF to 0 before

a paper tape of a program is read in from

a Teletype (TELETYPE ts a registered

trademark of *7:e TELFTTPF CCRP0A4T.RW .

In the 8K version, use the null command

to set the number of nulls to zero. In

the 4K version, this is accomplished by

patching location 46 octal to contain the

number of nulls to be typed plus 1.

(Depositing a 1 in location 46 would set

the number of nulls typed to zero.) When

you punch a paper tape of a program using

the list command, null should be set >=3

for 10 CPS terminals, >=6 for 30 CPS ter-

minals. When not making a tape, we recom-

mend that you use a null setting of 0 or 1

for Teletypes, and 2 or 3 for hard copy

30 CPS terminals. A setting of 0 will

work with Teletype compatible CRT's.

RUN RUN Starts execution of the program currently

in memory at the lowest numbered state-

ment. Run deletes all variables (does a

CLEAR) and restores DATA. If you have

stopped your program and wish to continue

execution at some point in the program,

use a direct GOTO statement to start

execution of your program at the desired

line. *CRLF=carriage return/line feed

RUN EDO (8K version only) optionally starting

at the specified line number

NEhJ NEM Deletes current program and all variables

TRE FCLLCMZWC COMMANDS ARE JFV TRE FX KERRKW ONLY

CONT CONT Continues program execution after a

control/C is typed or a STOP statement

is executed. You cannot continue after

any error, after modifying your program,

or before your program has been run.

One of the main purposes of CONT is de-

bugging. Suppose at some point after

running your program, nothing is printed.

This may be because your program is per-

forming some time consuming calculation,

but it may be because you have fallen

into an "infinite loop". An infinite loop

is a series of BASIC statements from

which there is no escape. The ALTAIR will

keep executing the series of statements

over and over, until you intervene or

until power to the ALTAIR is cut off.

If you suspect your program is in an

infinite loop, type in a control/C. In

the 8K version, the line number of the

statement BASIC was executing will be

typed out. After BASIC has typed out OK,

you can use PRINT to type out some of the

values of your variables. After examining

these values you may become satisfied that

your program is functioning correctly.

You should then type in CONT to continue

executing your program where it left off,

or type a direct GOTO statement to resume

execution of the program at a different

line. You could also use assignment (LET)

statements to set some of your variables

to different values. Remember, if you

control/C a program and expect to continue

it later, you must not get any errors or

type in any new program lines. If you

do, you won't be able to continue and will

get a "CN" (continue not) error. It is

impossible to continue a direct command.

CONT always resumes execution at the next

statement to be executed in your program

when control/C was typed.

CLOAD CLOAD P Loads the program named P from the

cassette tape. A NEW command is auto-

matically done before the CLOAD com-

mand is executed. When done, the CLOAD

will type out OK as usual. The one-

character program designator may be any

printing character. CSAVE and CLOAD

use I/O ports 6 § 7.

See Appendix I for more information.

CSAVE CSAVE P Saves on cassette tape the current pro-

gram in the ALTAIR's memory. The pro-

gram in memory is left unchanged. More

than one program may be stored on cassette

using this command. CSAVE and CLOAD use

I/O ports 6 § 7.

See Appendix I for more information

OPERATORS

SYMBOL SAMPLE STATEMENT

A=100

LET Z=E-5

B=-A

t 130 PRINT X+3

140 X=R*(B*D)

150 PRINT X/1.3

IbO Z=R+T+3

170 J=100-I

PURPOSE/USE

Assigns a value to a variable

The LET is optional

Negation. Note that 0-A is subtraction,

while -A is negation.

Exponentiation (8K version)

(equal to X*X*X in the sample statement)

0+0=1 0 to any other power = 0

AtB, with A negative and B not an integer

gives an FC error.

Multiplication

Division

Addition

Subtraction

RULES FOR EVALUATING EXPRESSIONS:

1) Operations of higher precedence are performed before opera-

tions of lower precedence. This means the multiplication and

divisions are performed before additions and subtractions. As

an example, 2+10/5 equals 4, not 2.4. When operations of equal

precedence are found in a formula, the left hand one is executed

first: 6-3+5=8, not -2.

2) The order in which operations are performed can always be

specified explicitly through the use of parentheses. For in-

stance, to add 5 to 3 and then divide that by 4, we would use

(5+3)/4, which equals 2. If instead we had used 5+3/4, we

would get 5.75 as a result (5 plus 3/4).

The precedence of operators used in evaluating expressions is as

follows, in order beginning with the highest precedence:

fFVcte; Operators Zested on the same Ztne have the same precedence J

1) FORMULAS ENCLOSED IN PARENTHESIS ARE ALhJAYS EVALUATED FIRST

5) + EXPONENTIATION C3R VER32YW ONLY;

3) NEGATION -X UHERE X MAY BE A FORMULA

4) * / MULTIPLICATION AND DIVISION

5) + - ADDITION AND SUBTRACTION

L) RELATIONAL OPERATORS: = E<2UAL

feq^aZ precedence for <> NOT Et2UAL

an s^; < LESS THAN

> GREATER THAN

<= LESS THAN OR E<2UAL

>= GREATER THAN OR Et2UAL

VERSION ONLY) (These 2 be^oM are Log^caZ Operators)

7) NOT LOGICAL AND BITWISE "NOT"

LIKE NEGATION, NOT TAKES ONLY THE

FORMULA TO ITS RIGHT AS AN ARGUMENT

a) AND LOGICAL AND BITWISE "AND"

OR LOGICAL AND BITWISE "OR"

In the 4K version of BASIC, relational operators can only be used

once in an IF statement. However, in the 8K version a relational ex-

pression can be used as part of any expression.

Relational Operator expressions will always have a value of True (-1)

or a value of False (0). Therefore, (5#4)=0, (5=5)=-l, (4>5)=0, (4<5)=-l,

etc. The THEN clause of an IF statement is executed whenever the formula

after the IF is not equal to 0. That is to say, IF X THEN... is equivalent

to IF X<>0 THEN... .

SYMBOL SAMPLE STATEMENT PURPOSE/USE

ID IF A=15 THEN 40

70 IF A<>0 THEN 5

30 IF B>100 THEN 5

1L0 IF B<3 THEN 10

Expression Equals Expression

Expression Does Not Equal Expression

Expression Greater Than Expression

Expression Less Than Expression

<=,=< 130 IF 100<=B+C THEN 10

>=,=> 110 IF (2=>R THEN 50

AND B IF A<5 AND B<B THEN 7

OR IF A<1 OR B<B THEN B

NOT IF NOT <23 THEN 4

Expression Less Than Or Equal

To Expression

Expression Greater Than Or Equal

To Expression

(RK Version cnZz/J If expression 1

(A<5) AND expression 2 (B<2) are both

true, then branch to line 7

(3K Version on^J If either expres-

sion 1 (A<1) OR expression 2 (B<2) is

true, then branch to line 2

f&K yerstcw on^z/J If expression

"NOT Q3" is true (because Q3 is

false), then branch to line 4

/Vote.- NOT fM9T *rne=faZseJ

AND, OR and NOT can be used for bit manipulation, and for performing

boolean operations.

These three operators convert their arguments to sixteen bit, signed

two's, complement integers in the range -32768 to +32767. They then per-

form the specified logical operation on them and return a result within

the same range. If the arguments are not in this range, an "FC" error

results.

The operations are performed in bitwise fashion, this means that each

bit of the result is obtained by examining the bit in the same position

for each argument.

The following truth table shows the logical relationship between bits

OPERATOR ARG. 1 ARG. 2

AND

RESULT

(cont.J

OPERATOR ARG. 1 ARG. 2 RESULT

OR 1 1 1

10 1

0 1 1

0 0 0

NOT 1 - 0

0 - 1

EXAMPLES: fin aH of the examples &eZoM, ZeaJtng zeroes on

wn^ers are not shcMn.J

b3 AND lb=lb Since 63 equals binary 111111 and 16 equals binary

10000, the result of the AND is binary 10000 or 16.

15 AND 14=14 15 equals binary 1111 and 14 equals binary 1110, so

15 AND 14 equals binary 1110 or 14.

-1 AND 5=6 -1 equals binary 1111111111111111 and 8 equals binary

1000, so the result is binary 1000 or 8 decimal.

4 AND 5=0 4 equals binary 100 and 2 equals binary 10, so the

result is binary 0 because none of the bits in either

argument match to give a 1 bit in the result.

4 OR 5=b Binary 100 OR'd with binary 10 equals binary 110, or

6 decimal.

10 OR 10=10 Binary 1010 OR'd with binary 1010 equals binary 1010,

or 10 decimal.

-1 OR -3=-l Binary 1111111111111111 (-1) OR'd with binary

1111111111111110 (-2) equals binary 1111111111111111,

or -1.

NOT D=-l The bit complement of binary 0 to 16 places is sixteen

ones (1111111111111111) or -1. Also NOT -1=0.

NOT X NOT X is equal to -(X+l). This is because to form the

sixteen bit two's complement of the number, you take the

bit (one's) complement and add one.

NOT l=-5 The sixteen bit complement of 1 is 1111111111111110,

which is equal to -(1+1) or -2.

A typical use of the bitwise operators is to test bits set in the

ALTAIR's inport ports which reflect the state of some external device.

Bit position 7 is the most significant bit of a byte, while position

0 is the least significant.

For instance, suppose bit 1 of I/O port 5 is 0 when the door to Room

X is closed, and 1 if the door is open. The following program will print

"Intruder Alert" if the door is opened:

10 IF NOT (INP(5) AND 2) THEN 10 This line will execute over

and over until bit 1 (mask-

ed or selected by the 2) be-

comes a 1. When that happens,

we go to line 20 .

ALERT" Line 20 will output "INTRUDER

ALERT".

statement 10 with a "WAIT" statement, which

This line delays the execution of the next

statement in the program until bit 1 of

1/0 port 5 becomes 1. The WAIT is much

faster than the equivalent IF statement

and also takes less bytes of program

storage.

The ALTAIR's sense switches may also be used as an input device by

the INP function. The program below prints out any changes in the sense

switches.

10 A=300:REt1 SET A TO A VALUE THAT DILL FORCE PRINTING

BO J=INP(E55):IF J=A THEN B0

30 PRINT J;:A=J:G0T0 BO

The following is another useful way of using relational operators:

1B5 A=-(B>C)*B-(B<=C)*C This statement will set the variable

A to MAX(B,C) = the larger of the two

variables B and C.

STATEMENTS

/Vote; -Tn tTze foZZoning description of statements, an arjMment of 7

or ^ denotes a nMmeric variaMe, X denotes a numeric expression, de-

notes a string expression and an Z or <7 denotes an expression tTzat is

trMncated to an integer before t/ze statement is executed. Truncation

means tMt any fractional part of t&e number is Zest, e.g. 3.3 becomes

3, 4.0Z. becomes

^n expression is a series of uariaMes, operators, function caMs

and constants M^ic/: after tTze operations and function caHs are performed

Msing t^e precedence rn^es, eva&Ma^es a numeric or string t?a%ne.

4 constant is either a number /3.J4J or a string ZiteraZ ("FWJ.

B0 PRINT "INTRUDER

However, we can replace

has exactly the same effect.

10 tit AIT 5,B

NAME EXAMPLE PUKPOSii/USE

DATA 10 DATA li3-.-lE3-..04 Specifies data, read from left to right.

Information appears in data statements

in the same order as it will be read in

the program. IN THE 4K VERSION OF BASIC,

DATA STATEMENTS MUST BE THE FIRST STATE-

MENTS ON A LINE. Expressions may also

appear in the 4K version data statements.

BO DATA " FOO",ZOO C3R Verstcn,) Strings may be read from

DATA statements. If you want the string

to contain leading spaces (blanks), colons

(:) or commas (,), you must enclose the

string in double quotes. It is impossible

to have a double quote within string data

or a string literal. (""MITS"" is illegal)

(RK Vers^cMj The user can define functions

like the built-in functions (SQR, SGN, ABS,

etc.) through the use of the DEF statement.

The name of the function is "FN" followed

by any legal variable name, for example:

FNX, FNJ7, FNKO, FNR2. User defined

functions are restricted to one line. A

function may be defined to be any expres-

sion, but may only have one argument. In

the example B 6 C are variables that are

used in the program. Executing the DEF

statement defines the function. User de-

fined functions can be redefined by exe-

cuting another DEF statement for the same

function. User defined string functions

are not allowed. "V" is called the dummy

variable.

Execution of this statement following the

above would cause Z to be set to 3/B+C,

but the value of V would be unchanged.

DIM 113 DIM A(3),B(10) Allocates space for matrices. All matrix

elements are set to zero by the DIM state-

ment.

114 DIM R3(5,5),D3(B,B,E) (SR Vers^cnJ Matrices can have more

than one dimension. Up to 255 dimen-

sions are allowed, but due to the re-

striction of 72 characters per line

the practical maximum is about 34

dimensions.

115 DIM <21(N),Z(E*I) Matrices can be dimensioned dynamically

during program execution. If a matrix

is not explicitly dimensioned with a DIM

statement, it is assumed to be a single

dimensioned matrix of whose single subscript

DEF 100 DEF FNA(V)=V/B+C

110 Z=FNA(3)

may range from 0 to 10 (eleven elements). , j

117 A(B)=4 If this statement was encountered before

a DIM statement for A was found in the

program, it would be as if a DIM A(10)

had been executed previous to the execu-

tion of line 117. All subscripts start

at zero (0), which means that DIM X(100)

really allocates 101 matrix elements.

END m END Terminates program execution without

printing a BREAK message, (see STOP)

CONT after an END statement causes exe-

cution to resume at the statement after

the END statement. END can be used any-

where in the program, and is optional.

FOR 300 FOR V=1 TO 1-3 STEP -b (see NEXT statement) V is set

equal to the value of the expres-

sion following the equal sign, in

this case 1. This value is called

the initial value. Then the state-

ments between FOR and NEXT are

executed. The final value is the

value of the expression following

the TO. The step is the value of

the expression following STEP. ^

When the NEXT statement is encoun-

tered, the step is added to the

variable.

3ld FOR V=1 TO 1-3 If no STEP was specified, it is

assumed to be one. If the step is

positive and the new value of the

variable is <= the final value (9.3

in this example), or the step value

is negative and the new value of

the variable is => the final value,

then the first statement following

the FOR statement is executed.

Otherwise, the statement following

the NEXT statement is executed.

All FOR loops execute the statements

between the FOR and the NEXT at

least once, even in cases like

FOR V=1 TO 0.

315 FOR V=10*N TO 3-4/(3 STEP S(3R(R) Note that expressions

(formulas) may be used for the in-

itial, final and step values in a

FOR loop. The values of the ex-

pressions are computed only once,

before the body of the FOR NEXT

loop is executed.

330 FOR V=1 TO 1 STEP -1

330 FOR U=1 TO 10: FOR U=1

GOTO 50 GOTO 100

When the statement after the NEXT

is executed, the loop variable is

never equal to the final value,

but is equal to whatever value

caused the FOR...NEXT loop to ter-

minate. The statements between

the FOR and its corresponding NEXT

in both examples above (310 § 320)

would be executed 9 times.

TO :NEXT L):NEXT h) Error: do not

use nested FOR...NEXT loops with

the same index variable.

FOR loop nesting is limited only

by the available memory,

(see Appendix D)

:hes to the statement specified.

GOSUB 10 GOSUB 110 Branches to the specified statement (910)

until a RETURN is encountered; when a

branch is then made to the statement

after the GOSUB. GOSUB nesting is limited

only by the available memory,

(see Appendix D)

IF...GOTO 33 IF X<=Y+B3-4 GOTO 13 (6R VersioHj Equivalent to IF...THEN,

except that IF...GOTO must be followed

by a line number, while IF...THEN can

be followed by either a line number

or another statement.

IF...THEN IF X<10 THEN 5 Branches to specified statement if the

relation is True.

30 IF X<0 THEN PRINT "X LESS THAN 0" Executes all of the

statements on the remainder of the line

after the THEN if the relation is True.

35 IF X=5 THEN 50:Z=A WARNING. The "Z=A" will never be

executed because if the relation is

true, BASIC will branch to line 50.

If the relation is false Basic will

proceed to the line after line 25.

Bb IF X<0 THEN PRINT "ERROR, X NEGATIVE": GOTO 350

In this example, if X is less than 0,

the PRINT statement will be executed

and then the GOTO statement will

branch to line 350. If the X was 0 or

positive, BASIC will proceed to

execute the lines after line 26.

INPUT 3 INPUT V,U,U3

5 INPUT "VALUE";V

Requests data from the terminal (to be

typed in). Each value must be separated

from the preceeding value by a comma (,).

The last value typed should be followed

by a carriage return. A "?" is typed as

a prompt character. In the 4K version, a

value typed in as a response to an INPUT

statement may be a formula, such as

2*SIN(.16)-3. However, in the 8K version,

only constants may be typed in as a re-

sponse to an INPUT statement, such as

4.SE-3 or "CAT". If more data was re-

quested in an INPUT statement than was

typed in, a "??" is printed and the rest

of the data should be typed in. If more

data was typed in than was requested,

the extra data will be ignored. The 8K

version will print the warning "EXTRA

IGNORED" when this happens. The 4K ver-

sion will not print a warning message.

(FX VerstCMj Strings must be input in the

same format as they are specified in DATA

statements.

(<% Vers^cnJ Optionally types a prompt

string ("VALUE") before requesting data

from the terminal. If carriage return

is typed to an input statement, BASIC

returns to command mode. Typing CONT

after an INPUT command has been inter-

rupted will cause execution to resume at

the INPUT statement.

LET 300 LET W=X

310V=5.1 Assigns a value to a variable

"LET" is optional.

NEXT 340 NEXT V

345 NEXT

350 NEXT V,h)

Marks the end of a FOR loop.

C3.K Version) If no variable is given,

matches the most recent FOR loop.

fRK VorstCMj A single NEXT may be used

to match multiple FOR statements.

Equivalent to NEXT V:NEXT W.

ON...GOTO 100 ON I GOTO 10,30,30,40 (FX VersionJ Branches to the line

indicated by the I'th number after

the GOTO. That is:

IF 1=1, THEN GOTO LINE 10

IF 1=2, THEN GOTO LINE 20

IF 1=3, THEN GOTO LINE 30

IF 1=4, THEN GOTO LINE 40.

If 1=0 or I attempts to select a non-

existent line (>=5 in this case), the

statement after the ON statement is

executed. However, if I is >255 or

<0, an FC error message will result.

As many line numbers as will fit on

a line can follow an ON...GOTO.

105 ON SGN(X)+2 GOTO H0,50,L0

This statement will branch to line 40

if the expression X is less than zero,

to line 50 if it equals zero, and to

line 60 if it is greater than zero.

ON...GOSUB

110 ON I GOSUB 50,bO (FR Version; Identical to "ON...GOTO",

except that a subroutine call (GOSUB) is

executed instead of a GOTO. RETURN from

the GOSUB branches to the statement after

the ON...GOSUB.

OUT 355 OUT I,J (RK Version; Sends the byte J to the

output port I. Both I

J must be >=0

and <=255.

POKE 357 POKE I,J CSR Version; The POKE statement stores

the byte specified by its second argu-

ment (J) into the location given by its

first argument (I). The byte to be stored

must be =>0 and <=255, or an FC error will

occur. The address (I) must be =>0 and

<=32767, or an FC error will result.

Careless use of the POKE statement will

probably cause you to "poke" BASIC to

death; that is, the machine will hang, and

you will have to reload BASIC and will

lose any program you had typed in. A

POKE to a non-existent memory location is

harmless. One of the main uses of POKE

is to pass arguments to machine language

subroutines. (see Appendix J) You could

also use PEEK and POKE to write a memory

diagnostic or an assembler in BASIC.

PRINT 3L0 PRINT X,Y;Z Prints the value of expressions on the

370 PRINT terminal. If the list of values to be

360 PRINT X,Y; printed out does not end with a comma (,)

310 PRINT "VALUE IS";A or a semicolon (;), then a carriage

400 PRINT AE,B, return/line feed is executed after all the

values have been printed. Strings enclosed

in quotes (") may also be printed. If a

semicolon separates two expressions in the

list, their values are printed next to

each other. If a comma appears after an

expression in the list, and the print head

is at print position 56 or more, then a

carriage return/line feed is executed.

If the print head is before print position

56, then spaces are printed until the car-

riage is at the beginning of the next 14

column field (until the carriage is at

column 14, 28, 42 or 56...). If there is no

list of expressions to be printed, as in

line 370 of the examples, then a carriage

return/line feed is executed.

410 PRINT MIDt(A3,B); (RK Version) String expressions may be

printed.

READ 410 READ ViM Reads data into specified variables from

a DATA statement. The first piece of data

read will be the first piece of data list-

ed in the first DATA statement of the pro-

gram. The second piece of data read will

be the second piece listed in the first

DATA statement, and so on. When all of

the data have been read from the first

DATA statement, the next piece of data to

be read will be the first piece listed in

the second DATA statement of the program.

Attempting to read more data than there

is in all the DATA statements in a pro-

gram will cause an OD (out of data) error.

In the 4K version, an SN error from a READ

statement can mean the data it was at-

tempting to read from a DATA statement was

improperly formatted. In the 8K version,

the line number given in the SN error will

refer to the line number where the error

actually is located.

Allows the programmer to put comments in

his program. REM statements are not exe-

cuted, but can be branched to. A REM

statement is terminated by end of line,

but not by a":".

In this case the V=0 will never be exe-

cuted by BASIC.

In this case V=0 will be executed

REM 500 REN NOtd SET V-0

505 REM SET V=0: V=0

50k V-0: REM SET V-0

RESTORE 510 RESTORE Allows the re-reading of DATA statements.

After a RESTORE, the next piece of data

read will be the first piece listed in

the first DATA statement of the program.

The second piece of data read will be

the second piece listed in the first DATA

statement, and so on as in a normal

READ operation.

RETURN 50 RETURN Causes a subroutine to return to the

statement after the most recently exe-

cuted GOSUB.

STOP 1000 STOP Causes a program to stop execution and to

enter command mode.

C3R Version; Prints BREAK IN LINE 9000.

(as per this example) C0NT after a STOP

branches to the statement following the

STOP.

UAIT B05 UAIT I,J,K (3R Version; This statement reads the

B0L MAIT I,J status of input port I, exclusive OR's

K with the status, and then AND's the re-

sult with J until a non-zero result is

obtained. Execution of the program con-

tinues at the statement following the

WAIT statement. If the WAIT statement

only has two arguments, K is assumed to

be zero. If you are waiting for a bit

to become zero, there should be a one in

the corresponding position of K. I, J

and K must be =>0 and <=255.

4K INTRINSIC FUNCTIONS

ABS(X) 150 PRINT ABS(X)

INT(X) 140 PRINT INT(X)

RND(X) 170 PRINT RND(X)

Gives the absolute value of the expression

X. ABS returns X if X>=0, -X otherwise.

Returns the largest integer less than or

equal to its argument X. For example:

INT(.23)=0, INT(7)=7, INT(-.1)=-1, INT

(-2)= -2, INT(1.1)=1.

The following would round X to D decimal

places: INT(X*10tD+.5)/10+D

Generates a random number between 0 and 1.

The argument X controls the generation of

random numbers as follows:

X<0 starts a new sequence of random

numbers using X. Calling RND with

the same X starts the same random

number sequence. X=0 gives the last

random number generated. Repeated

calls to RND(0) will always return

the same random number. X>0 gener-

ates a new random number between 0

and 1.

Note that (B-A)*RND(1)+A will gener-

ate a random number between A S B.

SGN(X) 230 PRINT SGN(X) Gives 1 if X>0, 0 if X=0, and -1 if X<0.

SIN(X) 110 PRINT SIN(X) Gives the sine of the expression X. X is

interpreted as being in radians. Note:

COS (X)=SIN(X+3.14159/2) and that 1 Radian

=180/PI degrees=57.2958 degrees; so that

the sine of X degrees= SIN(X/57.2958).

S(3R(X) 160 PRINT S(2R(X) Gives the square root of the argument X.

An FC error will occur if X is less than

zero.

TAB(I) B40 PRINT TAB(I) Spaces to the specified print position

(column) on the terminal. May be used

only in PRINT statements. Zero is the

leftmost column on the terminal, 71 the

rightmost. If the carriage is beyond

position I, then no printing is done. I

must be =>0 and <=255.

USR(I) BOO PRINT USR(I) Calls the user's machine language sub-

routine with the argument I. See POKE

PEEK and Appendix J.

8K FUNCTIONS finches aH those Msted M7K?er 4R JNyRJNSZC FWCyfONS

p^MS the foZZ.oMtMQ' tw a&Ztt-MM.J

ATN(X) BIO PRINT ATN(X)

COS(X) BOO PRINT COS(X)

EXP(X) 150 PRINT EXP(X)

FRE(X) B70 PRINT FRE(0)

INP(I) Bb5 PRINT INP(I)

Gives the arctangent of the argument X.

The result is returned in radians and

ranges from -PI/2 to PI/2. (PI/2=1.5708)

Gives the cosine of the expression X. X

is interpreted ias being in radians.

Gives the constant "E" (2.71828) raised

to the power X. (E+X) The maximum

argument that can be passed to EXP with-

out overflow occuring is 87.3365.

Gives the number of memory bytes currently

unused by BASIC. Memory allocated for

STRING space is not included in the count

returned by FRE. To find the number of

free bytes in STRING space, call FRE with

a STRING argument, (see FRE under STRING

FUNCTIONS)

Gives the status of (reads a byte from)

input port I. Result is =>0 and <=255.

LOG(X) IbO PRINT LOG(X)

PEEK 35b PRINT PEEK(I)

Gives the natural (Base ii) lonarithm of

Its argument X. To obtain the Huso Y

logarithm of X use the formula LOG (X)/LOG (Y)

Example: The base 10 (common) log of

7 = LOG(7)/ LOG(10).

The PEEK function returns the contents of

memory address I. The value returned will

be =>0 and <=255. If I is >32767 or <0,

an FC error will occur. An attempt to

read a non-existent memory address will

return 255. (see POKE statement)

POS(I) BbO PRINT POS(I)

SPC(I) B5Q PRINT SPC(I)

Gives the current position of the terminal

print head (or cursor on CRT's). The

leftmost character position on the terminal

is position zero and the rightmost is 71.

Prints I space (or blank) characters on

the terminal. May be used only in a

PRINT statement. X must be =>0 and <=255

or an FC error will result.

TAN(X) BQ0 PRINT TAN(X) Gives the tangent of the expression X.

X is interpreted as being in radians.

STRINGS (FX Version OnZz/J

1) A string may be from 0 to 255 characters in length. All string

variables end in a dollar sign ( $ ); for example, A$, B9$, K$,

HELL0$.

2) String matrices may be dimensioned exactly like numeric matrices.

For instance, DIM A$(10,10) creates a string matrix of 121 elements,

eleven rows by eleven columns (rows 0 to 10 and columns 0 to 10).

Each string matrix element is a complete string, which can be up to

255 characters in length.

3) The total number of characters in use in strings at any time during

program execution cannot execeed the amount of string space, or an

OS error will result. At initialization, you should set up string

space so that it can contain the maximum number of characters which

can be used by strings at any one time during program execution.

NAME EXAMPLE PURPOSE/USE

DIN B5 DIM A3(10,10) Allocates space for a pointer and length

for each element of a string matrix. No

string space is allocated. See Appendix D.

LET 37 LET A6="FOO"+V6 Assigns the value of a string expression

to a string variable. LET is optional.

String comparison operators. Comparison

is made on the basis of ASCII codes, a

character at a time until a difference

is found. If during the comparison of

two strings, the end of one is reached,

the shorter string is considered smaller,

Note that "A " is greater than "A" since

trailing spaces are significant.

30 LET Z3=R3+%3 String concatenation. The resulting

string must be less than 256 characters

in length or an LS error will occur.

INPUT 40 INPUT X3 Reads a string from the user's terminal.

String does not have to be quoted; but if

not, leading blanks will be ignored and

the string will be terminated on a "," or

":" character.

READ 50 READ X3 Reads a string from DATA statements within

the program. Strings do not have to be

quoted; but if they are not, they are

terminated on a "," or ":" character or

end of line and leading spaces are ignored.

See DATA for the format of string data.

PRINT bO PRINT X*

70 PRINT "F00"+A3 Prints the string expression on the user's

terminal.

STRING FUNCTIONS C8X Version OM^j

ASC(X3) 300 PRINT ASC(X3) Returns the ASCII numeric value of the

first character of the string expression

X$. See Appendix K for an ASCII/number

conversion table. An FC error will occur

if X$ is the null string.

CHR3M) 375 PRINT CHR3(I)

FRE(X3) 373 PRINT FREf"")

LEFT3(X3,I)

310 PRINT LEFT3(X3,I) string expression X$.

an FC error occurs.

40-

Returns a one character string whose single

character is the ASCII equivalent of the

value of the argument (I) which must be

=>0 and <=255. See Appendix K.

When called with a string argument, FRE

gives the number of free bytes in string

space.

Gives the leftmost I characters of the

If I<=0 or >255

LEN(X3) 330 PRINT LEN(X3)

MIDS(X$,I)

Gives the length of the string expression

X$ in characters (bytes). Non-printing

characters and blanks are counted as part

of the length.

MID$ called with two arguments returns

330 PRINT MID3(X3,I) characters from the string expression X$

starting at character position I. If

I>LEN(I$), then MID$ returns a null (zero

length) string. If I<=0 or >255, an FC

error occurs.

MID3(X3,I,J) MID$ called with three arguments returns

340 PRINT MID3(X3,I,J) a string expression composed of the

characters of the string expression X$

starting at the 1th character for J char-

acters. If I>LEN(X$), MID$ returns a null

string. If I or J <=0 or >255, an FC

error occurs. If J specifies more char-

acters than are left in the string, all

characters from the 1th on are returned.

RIGHTS(XS,I)

330 PRINT RIGHTS(XS,I)

STRS(X) 310 PRINT STRS(X)

VAL(XS) 330 PRINT VAL(XS)

Gives the rightmost I characters of

the string expression X$. When I<=0

or >255 an FC error will occur. If

I>=LEN(X$) then RIGHT$ returns all of

X$.

Gives a string which is the character

representation of the numeric expression

X. For instance, STR$(3.1)=" 3.1".

Returns the string expression X$ converted

to a number. For instance, VAL("3.1")=3.1

If the first non-space character of the

string is not a plus (+) or minus (-) sign

a digit or a decimal point (.) then zero

will be returned.

SPECIAL CHARACTERS

CHARACTER USE

@ Erases current line being typed, and types a carriage

return/line feed. An is usually a shift/P.

-*- f&acAxEPrczj or wafer Hue,) Erases last character typed.

If no more characters are left on the line, types a

carriage return/line feed. "-<-" is usually a shift/0.

CARRIAGE RETURN A carriage return must end every line typed in. Re-

turns print head or CRT cursor to the first position

(leftmost) on line. A line feed is always executed

after a carriage return.

Interrupts execution of a program or a list command.

Control/C has effect when a statement finishes exe-

cution, or in the case of interrupting a LIST com-

mand, when a complete line has finished printing. In

both cases a return is made to BASIC'S command level

and OK is typed.

C<% Version,) Prints "BREAK IN LINE XXXX" , where

XXXX is the line number of the next statement to

be executed.

A colon is used to separate statements on a line.

Colons may be used in direct and indirect statements.

The only limit on the number of statements per line

is the line length. It is not possible to GOTO or

GOSUB to the middle of a line.

CONTROL/O Typing a Control/0 once causes BASIC to suppress all

output until a return is made to command level, an

input statement is encountered, another control/0 is

typed, or an error occurs.

? Question marks are equivalent to PRINT. For instance,

? 2+2 is equivalent to PRINT 2+2. Question marks can

also be used in indirect statements. 10 ? X, when

listed will be typed as 10 PRINT X.

MISCELLANEOUS

1) To read in a paper tape with a program on it (8K Version), type a

control/0 and feed in tape. There will be no printing as the tape

is read in. Type control/0 again when the tape is through.

Alternatively, set nulls=0 and feed in the paper tape, and when done

reset nulls to the appropriate setting for your terminal.

Each line must be followed by two rubouts, or any other non-printing

character. If there are lines without line numbers (direct commands)

the ALTAIR will fall behind the input coming from paper tape, so

this in not recommending.

Using null in this fashion will produce a listing of your tape in

the 8K version (use control/0 method if you don't want a listing).

The null method is the only way to read in a tape in the 4K version.

To read in a paper tape of a program in the 4K version, set the

number of nulls typed on carriage return/line feed to zero by patch-

ing location 46 (octal) to be a 1. Feed in the paper tape. When

CONTROL/C

: (colon)

the tape has finished reading, stop the CPU and repatch location 46

to be the appropriate number of null characters (usually 0, so de-

posit a 1). When the tape is finished, BASIC will print SN ERROR

because of the "OK" at the end of the tape.

2) To punch a paper tape of a program, set the number of nulls to 3 for

110 BAUD terminals (Teletypes) and 6 for 300 BAUD terminals. Then,

type LIST; but, do not type a carriage return.

Now, turn on the terminal's paper tape punch. Put the terminal on

local and hold down the Repeat, Control, Shift and P keys at the same

time. Stop after you have punched about a 6 to 8 inch leader of

nulls. These nulls will be ignored by BASIC when the paper tape is

read in. Put the terminal back on line.

Now hit carriage return. After the program has finished punching,

put some trailer on the paper tape by holding down the same four

keys as before, with the terminal on local. After you have punched

about a six inch trailer, tear off the paper tape and save for

later use as desired.

3) Restarting BASIC at location zero (by toggling STOP, Examine loca-

tion 0, and RUN) will cause BASIC to return to command level and

type "OK". However, typing Control/C is preferred because Control/

C is guaranteed not to leave garbage on the stack and in variables,

and a Control C'd program may be continued, (see CONT command)

4) The maximum line length is 72 characters?* If you attempt to type too

many characters into a line, a bell (ASCII 7) is executed, and the

character you typed in will not be echoed. At this point you can

either type backarrow to delete part of the line, or at-sign to delete

thewhole line. The character you typed which caused BASIC to type

the bell is not inserted in the line as it occupies the character

position one beyond the end of the line.

*CLEAR CLEAR Deletes all variables.

CLEAR X f<% Version; Deletes all variables. When

used with an argument "X", sets the amount

of space to be allocated for use by string

variables to the number indicated by its

argument "X".

10 CLEAR SO C3R Version; Same as above; but, may be used

at the beginning of a program to set the exact

amount of string space needed, leaving a maxi-

mum amount of memory for the program itself.

NOTE: If no argument is given, the string

space is set at 200 by default. An OM error

will occur if an attempt is made to allocate

more string space than there is available

memory.

.**For inputting only.

HOW TO LOAD BASIC

When the ALTAIR is first turned on, there is random garbage in its

memory. BASIC is supplied on a paper tape or audio cassette. Somehow

the information on the paper tape or cassette must be transfered into the

computer. Programs that perform this type of information transfer are

called loaders.

Since initially there is nothing of use in memory; you must toggle

in, using the switches on the front panel, a 20 instruction bootstrap

loader. This loader will then load BASIC.

To load BASIC follow these steps:

1) Turn the ALTAIR on.

2) Raise the STOP switch and RESET switch simultaneously.

3) Turn your terminal (such as a Teletype) to LINE.

Because the instructions must be toggled in via the switches on the

front panel, it is rather inconvenient to specify the positions of each

switch as "up" or "down". Therefore, the switches are arranged in groups

of 3 as indicated by the broken lines below switches 0 through 15. To

specify the positions of each switch, we use the numbers 0 through 7 as

shown below:

3 SWITCH GROUP

LEFTMOST MIDDLE RIGHTMOST

Down

OCTAL

NUMBER

So, to put the octal number 315 in switches 0 through 7, the switches

would have the following positions:

7 6

UP UP

DOWN

-SWITCH

-POSITION

-OCTAL NO.

Note that switches 8 through IS were not used. Switches 0 through

7 correspond to the switches labeled DATA on the front panel. A memory

address would use all 16 switches.

The following program is the bootstrap loader for users loading from

paper tape, and not using a REV 0 Serial I/O Board.

OCTAL ADDRESS OCTAL DATA

000 041

001 17S

002 037 (for 8K; for 4K use 017)

003 061

004 022

005 000

006 333

007 000

010 017

011 330

012 333

013 001

014 275

015 310

016 055

017 167

020 300

021 351

022 003

023 000

The following 21 byte bootstrap loader is for users loading from a

paper tape and using a REV 0 Serial I/O Board on which the update changing

the flag bits has not been made. If the update has been made, use the

above bootstrap loader.

OCTAL ADDRESS OCTAL DATA

000 041

001 175

002 037 (for 8K; for 4K use 017)

003 061

004 023

005 000

006 333

007 000

010 346

011 040

012 310

013 333

014 001

015 275

016 310

017 055

020 167

OCTAL ADDRESS OCTAL DATA j

(cont.)" * ' ^

021 300

022 351

023 003

024 000

The following bootstrap loader is for users With BASIC supplied on

an audio cassette.

OCTAL ADDRESS OCTAL DATA

006 041

001 175

002 037 (for 8K; for 4K use 017)

003 061

004 022

005 000

006 333

007 006

010 017

011 330

012 333

013 007

014 275

015 310

016 055 ^

017 167 ^

020 300

021 351

022 003

023 000

To load a bootstrap loader:

1) Put switches 0 through 15 in the down position.

2) Raise EXAMINE.

3) Put 041 (data for address 000) in switches 0 through 7.

4) Raise DEPOSIT.

5) Put the data for the next address in switches 0 through 7.

6) Depress DEPOSIT NEXT.

7) Repeat steps 5 § 6 until the entire loader is toggled in.

8) Put switches 0 through 15 in the down position.

9) Raise EXAMINE.

10) Check that lights DO through D7 correspond with the data that should

be in address 000. A light on means the switch was up, a light off

means the switch was down. So for address 000, lights D1 through D4

and lights D6 § D7 should be off, and lights DO and DS should be on.

If the correct value is there, go to step 13. If the value is wrong,

continue with step 11.

11) Put the correct value in switches 0 through 7.

12) Raise DEPOSIT.

13) Depress EXAMINE NEXT.

14) Repeat steps 10 through 13, checking to see that the correct data is

in each corresponding address for the entire loader.

15) If you encountered any mistakes while checking the loader, go back

now and re-check the whole program to be sure it is corrected.

16) Put the tape of BASIC into the tape reader. Be sure the tape is

positioned at the beginning of the leader. The leader is the section

of tape at the beginning with 6 out of the 8 holes punched.

If you are loading from audio cassette, put the cassette in the re-

corder. Be sure the tape is fully rewound.

17) Put switches 0 through 15 in the down position.

18) Raise EXAMINE.

19) If you have connected to your terminal a REV 0 Serial I/O Board

on which the update changing the flag bits has not been made, raise

switch 14; if you are loading from an audio cassette, raise switch

15 also.

If you have a REV 0 Serial I/O Board which has been updated, or have

a REV 1 I/O Board, switch 14 should remain down and switch 15 should

be raised only if you are loading from audio cassette.

20) Turn on the tape reader and then depress RUN. Be sure RUN is depres-

sed while the reader is still on the leader. Do not depress run be-

fore turning on the reader, since this may cause the tape to be read

incorrectly.

If you are loading from a cassette, turn the cassette recorder to

Play'. Wait 15 seconds and then depress RUN.

21) Wait for the tape to be read in. This should take about 12 minutes

for 8K BASIC and 6 minutes for 4K BASIC. It takes about 4 minutes

to load 8K BASIC from cassette, and about 2 minutes for 4K BASIC.

Do not move the switches while the tape is being read in.

22J if a (J or an 0 is printed on the terminal as the tape reads in, the

tape has been mis-read and you should start over at step 1 on page

46.

23) When the tape finishes reading, BASIC should start up and print

MEMORY SIZE?. See Appendix B for the initialization procedure.

24) If BASIC refuses to load from the Audio Cassette, the ACR Demodulator

may need alignment. The flip side of the cassette contains 90 seconds

of 125's (octal) which were recorded at the same tape speed as BASIC.

Use the Input Test Program described on pages 22 and 28 of the ACR

manual to perform the necessary alignment.

APPENDIX A SUPPLEMENT

INITIALIZATION DIALOG

STARTING BASIC

Leave the sense switches as they were set for loading BASIC (Appen-

dix A). After the initialization dialog is complete, and BASIC types OK,

you are free to use the sense switches as an input device (I/O port 255).

After you have loaded BASIC, it will respond:

MEMORY SIZE?

If you type a carriage return to MEMORY SIZE?, BASIC will use all

the contiguous memory upwards from location zero that it can find. BASIC

will stop searching when it finds one byte of ROM or non-existent memory.

If you wish to allocate only part of the ALTAIR's memory to BASIC,

type the number of bytes of memory you wish to allocate in decimal. This

might be done, for instance, if you were using part of the memory for a

machine language subroutine.

There are 4096 bytes of memory in a 4K system, and 8192 bytes in an

8K system.

BASIC will then ask:

TERMINAL UIDTHf This is to set the output line width for

PRINT statements only. Type in the number

of characters for the line width for the

particular terminal or other output device

you are using. This may be any number

from 1 to 255, depending on the terminal.

If no answer is given (i.e. a carriage

return is typed) the line width is set

to 72 characters.

Now ALTAIR BASIC will enter a dialog which will allow you to delete

some of the arithmetic functions. Deleting these functions will give

more memory space to store your programs and variables. However, you will

not be able to call the functions you delete. Attempting to do so will

result in an FC error. The only way to restore a function that has been

deleted is to reload BASIC.

The following is the dialog which will occur:

4K Version

UANT SIN? Answer " Y " to retain SIN, SQR and RND.

If you answer " N ", asks next question.

MANT S(2R? Answer " Y " to retain SQR and RND.

If you answer " N ", asks next question.

UANT RND? Answer " Y " to retain RND.

Answer " N " to delete RND.

8K Version

DANT SIN-COS-TAN-ATN? Answer " Y " to retain all four of

the functions, " N "to delete all four,

or " A " to delete ATN only.

Now BASIC will type out:

XXXX BYTES FREE

ALTAIR BASIC VERSION 3-D

[FOUR-K VERSION] "XXXX" is the number of bytes

available for program, variables,

matrix storage and the stack. It

does not include string space.

(or)

[EIGHT-K VERSION]

You will now be ready to begin using ALTAIR BASIC.

APPENDIX M

ERROR MESSAGES

After an error occurs, BASIC returns to command level and types OK.

Variable values and the program text remain intact, but the program can

not be continued and all GOSUB and FOR context is lost.

When an error occurs in a direct statement, no line number is printed.

Format of error messages:

Direct Statement fXX ERROR

Indirect Statement ?XX ERROR IN YYYYY

In both of the above examples, "XX" will be the error code. The

"YYYYY" will be the line number where the error occured for the indirect

statement.

The following are the possible error codes and their meanings:

ERROR CODE MEANING

BS Bad Subscript. An attempt was made to reference a

matrix element which is outside the dimensions of the

matrix. In the 8K version, this error can occur if

the wrong number of dimensions are used in a matrix

reference; for instance, LET A(1,1,1)=Z when A has

been dimensioned DIM A(2,2).

DD Double Dimension. After a matrix was dimensioned,

another dimension statement for the same matrix was

encountered. This error often occurs if a matrix

has been given the default dimension 10 because a

statement like A(I)=3 is encountered and then later

in the program a DIM A(100) is found.

FC Function Call error. The parameter passed to a math

or string function was out of range.

FC errors can occur due to:

a negative matrix subscript (LET A(-1)=0)

an unreasonably large matrix subscript

(>32767)

LOG-negative or zero argument

SQR-negative argument

e) A+B with A negative and B not an integer

f) a call to USH before the address o!* the

machine language subroutine has been

patched in

g) calls to MID$, LEFT$, RIGHT$, INP, OUT,

WAIT, PEEK, POKE, TAB, SPC or ON...GOTO

with an improper argument.

ID Illegal Direct. You cannot use an INPUT or ft?! FX Version J

DEFFN statement as a direct command.

NF NEXT without FOR. The variable in a NEXT statement

corresponds to no previously executed FOR statement.

OD Out of Data. A READ statement was executed but all of

the DATA statements in the program have already been

read. The program tried to read too much data or insuf-

ficient data was included in the program.

OH Out of Memory. Program too large, too many variables,

too many FOR loops, too many GOSUB's, too complicated

an expression or any combination of the above, (see

Appendix D)

OV Overflow. The result of a calculation was too large to

be represented in BASIC'S number format. If an underflow

occurs, zero is given as the result and execution continues

without any error message being printed.

SN Syntax error. Missing parenthesis in an expression,

illegal character in a line, incorrect punctuation, etc.

RG RETURN without GOSUB. A RETURN statement was encountered

without a previous GOSUB statement being executed.

US Undefined Statement. An attempt was made to GOTO, GOSUB

or THEN to a statement which does not exist.

/U Division by Zero.

FX (Jnc^M^es c/ the prey^cMS cccZes w a&%tton to the

foZ^CM^g*. J

CN Continue error. Attempt to continue a program when

none exists, an error occured, or after a new line

was typed into the program.

Long String. Attempt was made by use of the concatenation

operator to create a string more than 255 characters long.

Out of String Space. Save your program on paper tape or

cassette, reload BASIC and allocate more string space

or use smaller strings or less string variables.

String Temporaries. A string expression was too complex.

Break it into two or more shorter ones.

Type Mismatch. The left hand side of an assignment

statement was a numeric variable and the right hand

side was a string, or vice versa; or, a function which

expected a string argument was given a numeric one or

vice versa.

Undefined Function. Reference was made to a user defined

function which had never been defined.

APPENDIX M

SPACE HINTS

In order to make your program smaller and save space, the following

hints may be useful.

1) Use multiple statements per line. There is a small amount of

overhead (5bytes) associated with each line in the program. Two of these

five bytes contain the line number of the line in binary. This means

that no matter how many digits you have in your line number (minimum line

number is 0, maximum is 6SS29), it takes the same number of bytes. Put-

ting as many statements as possible on a line will cut down on the number

of bytes used by your program.

2) Delete all unnecessary spaces from your program. For instance:

10 PRINT X, Y, Z

uses three more bytes than

10 PRINTX,Y,Z

Note: All spaces between the line number and the first non-

blank character are ignored.

3) Delete all REM statements. Each REM statement uses at least

one byte plus the number of bytes in the comment text. For instance,

the statement 130 REM THIS IS A COMMENT uses up 24 bytes of memory.

In the statement 140 X=X+Y: REM UPDATE SUM, the REM uses 14 bytes of

memory including the colon before the REM.

4) Use variables instead of constants. Suppose you use the constant

3.14159 ten times in your program. If you insert a statement

10 P=3.14159

in the program, and use P instead of 3.14159 each time it is needed, you

will save 40 bytes. This will also result in a speed improvement.

5) A program need not end with an END; so, an END statement at

the end of a program may be deleted.

6) Reuse the same variables. If you have a variable T which is used

to hold a temporary result in one part of the program and you need a tem-

porary variable later in your program, use it again. Or, if you are asking

the terminal user to give a YES or NO answer to two different questions

at two different times during the execution of the program, use the same

temporary variable A$ to store the reply.

7) Use GOSUB's to execute sections of program statements that per-

form identical actions.

8) If you are using the 8K version and don't need the features of

the 8K version to run your program, consider using the 4K version in-

stead. This will give you approximately 4.7K to work with in an 8K machine,

as opposed to the 1.6K you have available in an 8K machine running the

8K version of BASIC.

9) Use the zero elements of matrices; for instance, A(0), B(0,X).

STORAGE ALLOCATION INFORMATION

Simple (non-matrix) numeric variables like V use 6 bytes; 2 for the

variable name, and 4 for the value. Simple non-matrix string variables

also use 6 bytes; 2 for the variable name, 2 for the length, and 2 for a

pointer.

Matrix variables use a minimum of 12 bytes. Two bytes are used for

the variable name, two for the size of the matrix, two for the number of

dimensions and two for each dimension along with four bytes for each of

the matrix elements. \

String variables also use one byte of string space for each character

in the string. This is true whether the string variable is a simple string

variable like A$, or an element of a string matrix such as Ql$(5,2).

When a new function is defined by a DEF statement, 6 bytes are used

to store the definition.

Reserved words such as FOR, GOTO or NOT, and the names or the

intrinsic functions such as COS, INT and STR$ take up only one byte of

program storage. All other characters in programs use one byte of pro-

gram storage each.

When a program is being executed, space is dynamically allocated on

the stack as follows:

1) Each active FOR...NEXT loop uses 16 bytes.

2) Each active GOSUB (one that has not returned yet) uses 6 bytes.

3) Each parenthesis encountered in an expression uses 4 bytes and

each temporary result calculated in an expression uses 12 bytes.

.57

APPENDIX A

SUPPLEMENT

SPEED HINTS

The hints below should improve the execution time of your BASIC pro-

gram. Note that some of these hints are the same as those used to decrease

the space used by your programs. This means that in many cases you can

increase the efficiency of both the speed and size of your programs at

the same time.

1) Delete all unnecessary spaces and REM's from the program. This

may cause a small decrease in execution time because BASIC would otherwise

have to ignore or skip over spaces and REM statements.

2) TRZS ZS PROBABLY TRE A/OFT IMPORTANT SPEED RLNT BY A FACTOR OF

Use variables instead of constants. It takes more time to con-

vert a constant to its floating point representation than it does to fetch

the value of a simple or matrix variable. This is especially important

within FOR...NEXT loops or other code that is executed repeatedly.

3) Variables which are encountered first during the execution of

a BASIC program are allocated at the start of the variable table. This

means that a statement such as 5 A=0:B=A:C=A, will place A first, B second,

and C third in the symbol table (assuming line 5 is thie first statement

executed in the program). Later in the program, when BASIC finds a refer-

ence to the variable A, it will search only one entry in the symbol table

to find A, two entries to find B and three entries to find C, etc.

4) f<% FerstonJ NEXT statements without the index variable. NEXT

is somewhat faster than NEXT I because no check is made to see if the

variable specified in the NEXT is the same as the variable in the most re-

cent FOR statement.

5) Use the 8K version instead of the 4K version. The 8K version

is about 40% faster than the 4K due to improvements in the floating point

arithmetic routines.

6) The math functions in the 8K version are much faster than their

counterparts simulated in the 4K version, (see Appendix G)

APPENDIX M

DERIVED FUNCTIONS

The following functions, while not intrinsic to ALTAIR BASIC, can be

calculated using the existing BASIC functions.

FUNCTION

SECANT

COSECANT

COTANGENT

INVERSE SINE

INVERSE COSINE

INVERSE SECANT

INVERSE COSECANT

INVERSE COTANGENT

HYPERBOLIC SINE

HYPERBOLIC COSINE

HYPERBOLIC TANGENT

HYPERBOLIC SECANT

HYPERBOLIC COSECANT

HYPERBOLIC COTANGENT

INVERSE HYPERBOLIC

SINE

INVERSE HYPERBOLIC

COSINE

INVERSE HYPERBOLIC

TANGENT

INVERSE HYPERBOLIC

SECANT

INVERSE HYPERBOLIC

COSECANT

INVERSE HYPERBOLIC

COTANGENT

FUNCTION EXPRESSED IN TERMS OF BASIC FUNCTIONS

SEC(X) = l/COS(X)

CSC(X) = 1/SIN(X)

COT(X) = 1/TAN(X)

ARCSIN(X) = ATN(X/SQR(-X*X+1))

ARCCOS(X) = -ATN(X/SQR(-X*X+1))+1.5708

ARCSEC(X) = ATN(SQR(X*X-1))+(SGN(X)-1)*1.5708

ARCCSC(X) = ATN(1/SQR(X*X-1))+(SGN(X)-1)"1.5708

ARCCOT(X) = -ATN(X)+1.5708

SINH(X) = (EXP(X)-EXP(-X))/2

COSH(X) = (EXP(X)+EXP(-X))/2

TANH(X) = -EXP(-X)/(EXP(X)+EXP(-X))*2+1

SECH(X) = 2/(EXP(X)+EXP(-X))

CSCH(X) = 2/(EXP(X)-EXP(-X))

COTH(X) = EXP(-X)/(EXP(X)-EXP(-X))*2+1

ARGSINH(X) = LOG(X+SQR(X*X+l))

ARGCOSH(X) = LOG(X+SQR(X*X-l))

ARGTANH(X) = LOG((l+X)/(l-X))/2

ARGSECH(X) = LOG((SQR(-X*X+l)+l)/X)

ARGCSCH(X) = L0G((SGN(X)*SQR(X*X+1)+1)/X)

ARGCOTH(X) = LOG((X+l)/(X-l))/2

APPENDIX M

SIMULATED MATH FUNCTIONS

The following subroutines are intended for 4K BASIC users who want

to use the transcendental functions not built into 4K BASIC. The cor-

responding routines for these functions in the 8K version are much faster

and more accurate. The REM statements in these subroutines are given for

documentation purposes only, and should not be typed in because they take

up a large amount of memory.

The following are the subroutine calls and their 8K equivalents:

The unneeded subroutines should not be typed in. Please note which

variables are used by each subroutine. Also note that TAN and COS require

that the SIN function be retained when BASIC is loaded and initialized.

bOOOO REM EXPONENTIATION: P^=X1TYT

L0010 REM NEED: EXPn LOG

bOOBO REM VARIABLES USED:

b0030 P1=l : E1=0 : IF Y^=0 THEN RETURN

b0040 IF X1<0 THEN IF INT(Y1)=YT THEN P1=1-3*Y1+4*INT(Y1/B) : X1=-X1

b0050 IF X^<>0 THEN GOSUB bOOlO : X1=Y1*LT : GOSUB bOlbO

bOObO P^P^EI : RETURN

b0070 REM NATURAL LOGARITHM: L1=L0G(X1)

bOOaO REM VARIABLES USED: A1nB1-,C1iE'l-,L'lnX'l

bOOlO E^=0 : IF X1<=0 THEN PRINT "LOG FC ERROR"^ : STOP

bOOIS A^=l : B^=B : : REM THIS DILL SPEED UP THE FOLLOWING

bOlOO IF X^>=A^ THEN : : GOTO bOlOO

bOHO IF X*=!<C^ THEN : : GOTO bOHO

bOlBO 707107)/(X1+.707107) :

b0130 L1= (((-

%1H71)

*L^+B. 5353^) - 5) * -

b^3147

b0135 RETURN

bOl^O REM EXPONENTIAL: E^EXP(X^)

b0150 REM VARIABLES USED: A'hEI-.LlnX'l

bOlbO L^=INT(1.44B7*X^)+1 : IF L1<1E7 THEN bOlBO

b0170 IF X1>0 THEN PRINT "EXP OV ERROR"^ : STOP

b0175 E^=0 : RETURN

bOlBO E^=.b^3147*L^-X5 : A^=1.3BiaaE-3-1.4131bE-H*E1

bOllO A^=(-3013bE-3).lb57WE-B)

bOlTS E^=

(((A*!-. Ibbbb5) . 5) *E1-1)

*E^+1 : AT^B

b01*=17 IF L^<=0 THEN A^=-5 : L^-LT : IF L1=0 THEN RETURN

8K EQUIVALENT SUBROUTINE CALL

P9=X9+Y9

L9=LOG(X9)

E9=EXP(X9)

C9=COS(X9)

T9=TAN(X9)

A9=ATN(X9)

GOSUB 60030

GOSUB 60090

GOSUB 60160

GOSUB 60240

GOSUB 60280

GOSUB 60310

bOEOO FOR X1=l TO LI : E1=A1*E1 : NEXT XT : RETURN

bOElO REM COSINE: C1=COS(X1)

LOEEO REM N-B- SIN MUST BE RETAINED AT LOAD-TINE

L0E30 REM VARIABLES USED: CliXI

bOBHO C1=SIN(X1+1.5706) : RETURN

b0350 REN TANGENT: T1=TAN(X1)

bOBLO REN NEEDS COS- (SIN NUST BE RETAINED AT LOAD-TINE)

b0B70 REN VARIABLES USED: CliTI.XI

bOBRO GOSUB L0340 : T1=SIN(X1)/C1 : RETURN

LOBIO REN ARCTANGENT: A1=ATN(X1)

b0300 REN VARIABLES USED: A1iB1-,C1-.T1nX1

L0310 T1=SGN(X1): X1=ABS(X1): C1=0 : IF X1>1 THEN C1=l : X1=l/X1

L0330 A1=X1*X1 : B1=((B.6bb33E-3*A1-l.blb57E-B)*A1+4.B101bE-B)*A1

^0330 B1=((((B1-7.5BR1E-3)* A1+.10b5b3)* A1-.143031)*A1+.11113b)*A1

L0340 A1=((B1-.33333E)*A1+1)*X1 : IF C1=l THEN A1-1.S70B-A1

b0350 A1=T1*A1 : RETURN

APPENDIX A SUPPLEMENT

CONVERTING BASIC PROGRAMS NOT WRITTEN FOR THE ALTAIR

Though implementations of BASIC on different computers are in many

ways similar, there are some incompatibilites which you should watch for

if you are planning to convert some BASIC programs that were not written

for the ALTAIR.

1) Matrix subscripts. Some BASICs use " [ " and " ] " to denote

matrix subscripts. ALTAIR BASIC uses " ( " and " ) ".

2) Strings. A number of BASICs force you to dimension (declare)

the length of strings before you use them. You should remove all

dimension statements of this type from the program. In some of

these BASICs, a declaration of the form DIM A$(I,J) declares a string

matrix of J elements each of which has a length I. Convert DIM

statements of this type to equivalent ones in ALTAIR BASIC: DIM A$(J).

ALTAIR BASIC uses " + " for string concatenation, not " , " or "

ALTAIR BASIC uses LEFT$, RIGHT$ and MID$ to take substrings of

strings. Other BASICs use A$(I) to access the 1th character of

the string A$, and A$(I,J) to take a substring of A$ from charac-

ter position I to character position J. Convert as follows:

OLD NEW

A$(I) MID$(A$,I,1)

A$(I,J) MID$(A$,I,J-I+1)

This assumes that the reference to a substring of A$ is in an expres-

sion or is on the right side of an assignment. If the reference to

A$ is on the left hand side of an assignment, and X$ is the string

expression used to replace characters in A$, convert as follows:

OLD NEW

A$(I)=X$ A$=LEFT$(A$,1-1)+X$+MID$(A$,1+1)

A$(I,J)=X$ A$=LEFT$(A$,1-1)+X$+MID$(A$,J+l)

3) Multiple assignments. Some BASICs allow statements of the

form: 500 LET B=C=0. This statement would set the variables B

§ C to zero.

In 8K ALTAIR BASIC this has an entirely different effect. All the

" ='s " to the right of the first one would be interpreted as logical

comparison operators. This would set the variable B to -1 if C

equaled 0. If C did not equal 0, B would be set to 0. The easiest

way to convert statements like this one is to rewrite them as follows:

500 C-0:B=C.

4) Some BASICs use " '\ " instead of " : " to delimit multiple

statements per line. Change the " \'s " to " :'s " in the program.

5) Paper tapes punched by other BASICs may have no nulls at the end

of each line, instead of the three per line recommended for use with

ALTAIR BASIC.

To get around this, try to use the tape feed control on the Teletype

to stop the tape from reading as soon as ALTAIR BASIC types a car-

riage return at the end of the line. Wait a second, and then continue

feeding in the tape.

When you have finished reading in the paper tape of the program, be

sure to punch a new tape in ALTAIR BASIC'S format. This will save

you from having to repeat this process a second time.

6) Programs which use the MAT functions available in some BASICs

will have to be re-written using FOR...NEXT loops to perform the

appropriate operations.

APPENDIX A SUPPLEMENT

USING THE ACR INTERFACE

NOTE; T&e cassette features, CL&4P and C5/4VE, are onZz/

present in 5X BAFJCs M^ic?! are districted on cassette.

BASIC on paper tape MiZZ gi^e t/ze z^ser abo^t more

&z/tes of free memory, &nt it MiZZ not recognise t&e CL0/4D

or commands.

The CSAVE command saves a program on cassette tape. CSAVE takes one

argument which can be any printing character. CSAVE can be given directly

or in a program. Before giving the CSAVE command start your audio recorder

on Record, noting the position of the tape.

CSAVE writes data on channel 7 and expects the device status from

channel 6. Patches can easily be made to change these channel numbers.

When CSAVE is finished, execution will continue with the next state-

ment. What is written onto the tape is BASIC'S internal representation

of the program in memory. The amount of data written onto the tape will

be equal to the size of the program in memory plus seven.

Variable values are not saved on the tape, nor are they affected by

the CSAVE command. The number of nulls being printed on your terminal

at the start of each line has no affect on the CSAVE or CLOAD commands.

CLOAD takes its one character argument just like the CSAVE command.

For example, CLOAD E.

The CLOAD command first executes a "NEW" command, erasing the cur-

rent program and all variable values. The CLOAD command should be given

before you put your cassette recorder on Play.

BASIC will read a byte from channel 7 whenever the character ready

flag comes up on channel 6. When BASIC finds the program on the tape,

it will read all characters received from the tape into memory until it

finds three consecutive zeros which mark the end of the program. Then

BASIC will return to command level and type "OK".

Statements given on the same line as a CLOAD command are ignored.

The program on the cassette is not in a checksummed format, so the pro-

gram must be checked to make sure it read in properly.

If BASIC does not return to command level and type "OK", it means

that BASIC either never found a file with the right filename character,

or that BASIC found the file but the file never ended with three con-

secutive zeros. By carefully watching the front panel lights, you can

tell if BASIC ever finds a file with the right name.

Stopping the ALTAIR and restarting it at location 0 will prevent

BASIC from searching forever. However, it is likely that there will

either be no program in the machine, or a partial program that has errors.

Typing NEW will always clear out whatever program is in the machine.

Reading and writing data from the cassette is done with the INP, OUT

and WAIT statements. Any block of data written on the tape should have

its beginning marked with a character. The main thing to be careful of

is allowing your program to fall behind while data passes by unread.

Data read from the cassette should be stored in a matrix, since

there isn't time to process data as it is being read in. You will pro-

bably want to detect the end of data on the tape with a special character.

APPENDIX M

BASIC/MACHINE LANGUAGE INTERFACE

In all versions of BASIC the user can link to a machine language

subroutine. The first step is to set aside enough memory for the sub-

routine. When BASIC asks "MEMORY SIZE?", you shouldn't type a return,

because BASIC would then write into all of memory trying to find out

how much memory your machine has and then use whatever memory it finds.

The memory that BASIC actually uses is constantly modified, so you

cannot store your machine language routine in those locations.

BASIC always uses memory starting at location 0 and as high upwards

as you let it. BASIC cannot use non-contiguous blocks of memory. There-

fore, it is best to reserve the top locations of memory for your machine

language program.

For example, if you have a 4K machine and want to use a 200 byte sub-

routine, you should set memory size to 3896. Remember, BASIC always ac-

cepts numbers in decimal and that 4K is really 2+12=4096 rather than 4000.

Now BASIC will not use any location >=* 3896.

If you try to allocate too much memory for your machine language pro-

gram, you will get an OM (out of memory) error. This is because there is

a certain amount of memory that BASIC must have or it will give an OM

error and go back to the "MEMORY SIZE?" question.

The starting location of your routine must be stored in a Ideation

known as "USRLOC". The exact octal location of USRLOC will be given with

each distributed version of BASIC. It is not the same for the 4K and 8K

versions. USRLOC for Version 3.0: 8K (both paper tape § cassette) = lll(octal)

4K=103(octal)

Initially USRLOC is set up to contain the address of "ILLFUN", which

is the routine that gives an FC (function call) error. USRLOC is the two

byte absolute address of the location BASIC calls when USR is invoked.

USR is a function just like ABS or INT and is called as follows:

10 X=USR(3).

When your routine is called the stack pointer is set up and you are

allowed to use up to 8 levels of stack (16 bytes). If you want to use

more, you have to save BASIC'S stack pointer (SP), set up your own, and

restore BASIC'S before you return back to BASIC.

All of the registers (A, B, C, D, E, H, L and PSW) can be changed.

It is dangerous to modify locations in BASIC itself unless you know what

you are doing. This is unlikely unless you have purchased a source copy

of BASIC. Popping more entries off of the stack than you put on is almost

guaranteed to cause trouble.

To retrieve the argument passed to USR, you must call the routine

whose address is given in location 4 and 5 (DEINT). The low order 8 bits

of an address are always stored in the lower address (4 in this case), and

the high order 8 bits are stored in the next (higher) memory address (5

in this case).

The argument to USR is truncated to an integer (calling USR with 3.8

is the same as calling it with 3). If the argument is greater than 32767

or less than -32768, an FC error will result. When DEINT returns, the

two byte signed value of the argument will be in registers D § E. The

high order byte would be in D, the low order byte in E. For instance:

if the argument to USR was -1, D would equal 255 and E would equal 255;

if the argument was 400, D would equal 1 and E would equal 144.

To pass back a value from USR, set up a two byte value in registers

B and call the routine whose address is given in locations 6 and 7.

B should be set up in the same manner that D 5 E are when a value is

passed to USR (A should contain the high order byte and B the low order

byte).

If the routine whose address is given in locations 6 and 7 is not

called, the function USR in the user's program will be an identity func-

tion. That is, USR(X) will equal X.

At the end of the USR routine a RET must be done to get back to

BASIC. The BASIC program is completely stopped while USR is being exe-

cuted and the program will not be continued until USR returns.

In the 4K version, the USR routine should not enable interrupts from

a device. 4K BASIC uses the RST 7 location (56 decimal, 70 octal) to store

a subroutine. If an interrupt occurs, this subroutine will be called which

will have an undetermined and undesirable effect on the way BASIC behaves.

In the 8K BASIC, locations 56, 57 and 58 decimal have been set aside

to store a JMP to a user-provided interrupt service routine. Initially

a RET instruction is stored at location 56, so until a user sets up the

call to his interrupt service routine, interrupts will have no effect.

Care must be taken in interrupt routines to save and restore the

stack pointer, (A, B, C, D, E, H 5 L) and the PSW. Interrupt routines

can pass data using PEEK, and can receive data using POKE.

The interrupt service routine should re-enable interrupts with an EI

instruction before it returns, as interrupts are automatically disabled

when the interrupt occurs. If this procedure is not followed, the inter-

rupt service routine will never "see" another interrupt.

Though there is only one way of calling a machine language subroutine,

this does not restrict the user to a single subroutine. The argument pas-

sed to USR can be used to determine which routine gets called. Multiple

arguments to a machine language routine can be passed with POKE or through

multiple calls to USR by the BASIC program.

The machine language routine can be loaded from paper tape or cassette

before or after BASIC is loaded. The checksum loader, an unchecksummed

loader, the console switches, or more conveniently the POKE function can be

used to load the routine.

A common use of USR for 4K users will be doing IN's and OUT's to

special devices. For example, on a 4K machine a user wants USR to pass

back the value of the front panel switch register:

Answer to MEMORY SIZE? : 4050

USRLOC patched to contain 117,322]=7722 Base 8=4050 decimal

At location 4050=7722 Basei

8 put:

7722/333 IN 255 ;(255 Base 10=377 Base 8) Get

7723/377 ;the value of the switches in A

7724/107 MOV B,A ;B gets low part of answer

7725/257 XRA A ;A gets high part of answer

7726/052 LHLD 6 ;get address of routine

7727/006

7730/000 ;that floats [A,B]

7731/351 PCHL ;go to that routine which will

;return to BASIC

;with the answer

MORE ON PEEK AND POKE KERFJON (WLYJ

As mentioned before, POKE can be used to set up your machine language

routine in high memory. BASIC does not restrict which addresses you can

POKE. Modifying USRLOC can be accomplished using two successive calls to

POKE. Patches whibh a user wishes to include in his BASIC can also be

made using POKE.

Using the PEEK function and OUT statement of 8K BASIC, the user can

write a binary dump program in BASIC. Using INP and POKE it is possible

to write a binary loader.

PEEK and POKE can be used to store byte oriented information. When

you initialize BASIC, answer the MEMORY SIZE? question with the amount of

memory in your ALTAIR minus the amount of memory you wish to use as stor-

age for byte formatted data.

You are now free to use the memory in the top of memory in your ALTAIR

as byte storage. See PEEK and POKE in the Reference Material for a further

description of their parameters.

APPENDIX M

ASCII CHARACTER CODES

DECIMAL CHAR. DECIMAL CHAR. DECIMAL CHA!

000 NUL 043 + 086 V

001 SOH 044 * 087 W

002 STX 045 -088 X

003 ETX 046 089 Y

004 EOT 047 / 090 Z

005 ENQ 048 0 091 [

006 ACK 049 1 092 \

007 BEL 050 2 093 ]

008 BS 051 3 094 +

009 HT 052 4 095 -t-

010 LF 053 5 096 **

Oil VT 054 6 097 a

012 FF 055 7 098 b

013 CR 056 8 099 c

014 SO 057 9 100 d

015 SI 058 101 e

016 DLE 059 102 f

017 DC1 060 < 103 g

018 DC 2 061 = 104 h

019 DC3 062 > 105 i

020 DC4 063 ? 106 j

021 NAK 064 e 107 k

022 SYN 065 A 108 1

023 ETB 066 B 109 m

024 CAN 067 C 110 n

025 EM 068 D 111 o

026 SUB 069 E 112 P

027 ESCAPE 070 F 113 q

028 FS 071 G 114 r

029 GS 072 H 115 s

030 RS 073 1 116 t

031 US 074 J 117 u

032 SPACE 075 K 118 V

033 t 076 L 119 w

034 " 077 M 120 X

035 # 078 N 121 y

036 $ 079 0 122 z

037 % 080 P * 123 {

038 081 Q 124 t

039 082 R 125 }

040 ( 083 S 126 ^

041 ) 084 T 127 DEL

042 085 U

LF=Line Feed FF=Form Feed CR=Carriage Return DEL=Rubout

CHR$ is a string function which returns a one character string which

contains the ASCII equivalent of the argument, according to the conversion

table on the preceeding page. ASC takes the first character of a string

and converts it to its ASCII decimal value.

One of the most common uses of CHR$ is to send a special character

to the user's terminal. The most often used of these characters is the

BEL (ASCII 7). Printing this character will cause a bell to ring on some

terminals and a "beep" on many CRT's. This may be used as a preface to

an error message, as a novelty, or just to wake up the user if he has

fallen asleep. (Example: PRINT CHR$(7);)

A major use of special characters is on those CRT's that have cursor

positioning and other special functions (such as turning on a hard copy

printer).

As an example, try sending a form feed (CHR$(12)) to your CRT. On

most CRT's this will usually cause the screen to erase and the cursor to

"home" or move to the upper left corner.

Some CRT's give the user the capability of drawing graphs and curves

in a special point-plotter mode. This feature may easily be taken advan-

tage of through use of ALTAIR BASIC'S CHR$ function.

APPENDIX L

EXTENDED BASIC

When EXTENDED BASIC is sent out, the BASIC manual will be updated

to contain an extensive section about EXTENDED BASIC. Also, at this time

the part of the manual relating to the 4K and 8K versions will be revised

to correct any errors and explain more carefully the areas users are hav-

ing trouble with. This section is here mainly to explain what EXTENDED

BASIC will contain.

INTEGER VARIABLES These are stored as double byte signed quantities

ranging from -32768 to +32767. They take up half as much space as normal

variables and are about ten times as fast for arithmetic. They are denoted

by using a percent sign (%) after the variable name. The user doesn't

have to worry about conversion and can mix integers with other variable

types in expressions. The speed improvement caused by using integers for

loop variables, matrix indices, and as arguments to functions such as

AND, OR or NOT will be substantial. An integer matrix of the same dimen-

sions as a floating point matrix will require half as much memory.

DOUBLE-PRECISION Double-Precision variables are almost the oppo-

site of integer variables, requiring twice as much space (8bytes per value)

and taking 2 to 3 times as long to do arithmetic as single-precision

variables. Double-Precision variables are denoted by using a number sign

(#) after the variable name. They provide over 16 digits of accuracy.

Functions like SIN, ATN and EXP will convert their arguments to single-

precision, so the results of these functions will only be good to 6 digits.

Negation, addition, subtraction, multiplication, division, comparision,

input, output and conversion are the only routines that deal with Double-

Precision values. Once again, formulas may freely mix Double-Precision

values with other numeric values and conversion of the other values to

Double-Precision will be done automatically.

PRINT USING Much like COBOL picture clauses or FORTRAN format

statements, PRINT USING provides a BASIC user with complete control over

his output format. The user can control how many digits of a number are

printed, whether the number is printed in scientific notation and the

placement of text in output. All of this can be done in the 8K version

using string functions such as STR$ and MID$, but PRINT USING makes it

much easier.

DISK I/O EXTENDED BASIC will come in two versions, disk and non-

disk. There will only be a copying charge to switch from one to the

other. With disk features, EXTENDED BASIC will allow the user to save and

recall programs and data files from the ALTAIR FLOPPY DISK. Random ac-

cess as well as sequential access will be provided. Simultaneous use of

multiple data files will be allowed. Utilities will format new disks,

delete files and print directories. These will be BASIC programs using

special BASIC functions to get access to' disk information such as file

length, etc. User programs can also access these disk functions, enabling

the user to write his own file access method or other special purpose

disk routine. The file format can be changed to allow the use of other

(non-floppy) disks. This type of modification will be done by Ml'i'S under

special arrangement.

OTHER FEATURES Other nice features which will be added are:

Fancy Error Messages

An ELSE clause in IF statements

LIST, DELETE commands with line range as arguments

Deleting Matrices in a program

TRACE ON/OFF commands to monitor program flow

EXCHANGE statement to switch variable values (this will speed

up string sorts by at least a factor of two).

Multi-Argument, user defined functions with string arguments

and values allowed

Other features contemplated for future release are:

A multiple user BASIC

Explicit matrix manipulation

Virtual matrices

Statement modifiers

Record I/O

Paramaterized GOSUB

Compilation

Multiple USR functions

"Chaining"

EXTENDED BASIC will use about 11K of memory for its own code (10K

for the non-disk version) leaving IK free on a 12K machine. It will take

almost 20 minutes to load from paper tape, 7 minutes from cassette, and

less than 5 seconds to load from disk.

We welcome any suggestions concerning current features or possible

additions of extra features. Just send them to the ALTAIR SOFTWARE

DEPARTMENT.

APPENDIX M

BASIC TEXTS

Below are a few of the many texts that may be helpful in learning

BASIC.

1) BASIC PROGRAMMING, John G. Kemeny, Thomas E Kurtz, 1967, pl45

2) BASIC, Albrecht, Finkel and Brown, 1973

3) A GUIDED TOUR OF COMPUTER PROGRAMMING IN BASIC, Thomas A Dwyer

and Michael S. Kaufman; Boston: Houghton Mifflin Co., 1973

Books numbered 1 $ 2 may be obtained from:

People's Computer Company

P.O. Box 310

Menlo Park, California

94025

They also have other books of interest, such as:

101 BASIC GAMES, Ed. David Ahl, 1974 p250

WHAT TO DO AFTER YOU HIT RETURN or PCC's FIRST

BOOK OF COMPUTER GAMES

COMPUTER LIB

DREAM MACHINES, Theodore H. Nelson, 1974, pl86

ALTAIR EXTENDED BASIC

PRELIMINARY DOCUMENTATION

THE FOLLOWING PAGES CONTAIN A CONDENSED VERSION OF THE

COMPLETE "ALTAIR EXTENDED BASIC" DOCUMENTATION.

In order to get this software to our customers with a

minimum of delay, it was decided to print this prelim-

inary documentation. This will help to expedite the

deliveries. The complete manual will be printed at a

later date, and will be in much the same format as the

previous existing BASIC documentation.

READ THESE PAGES OVER CAREFULLY. SOME OF THE INFOR-

MATION CONTAINED HERE ALSO APPLIES TO THE 4K AND 8K

VERSIONS OF BASIC.

This is meant to be an additional section to the

"ALTAIR BASIC REFERENCE MANUAL", and not a sepa-

rate manual in itself.

December '75

ALTAIR EXTENDED BASIC

ALTAIR EXTENDED BASIC Includes all of the features found In the 8K

version of BASIC, with some variations. There are also a large number of

additional features making this version one of the most powerful BASICs

available.

The following section contains the EXTENDED BASIC features and Its

variations from the 8K BASIC.

NAME

DELETE

LIST

COMMANDS

EXAMPLE

DELETE X

DELETE -X

PURPOSE/USE

Deletes line In a program with

the line number "X". "ILLEGAL

FUNCTION CALL" error occurs 1f

there Is no line "X".

Deletes all lines In a program up

to and Including line number "X".

"ILLEGAL FUNCTION CALL" 1f no line

"X".

Deletes all lines In a program from

the line number equal to or greater

than "Y" up to and Including the

first line equal to or less than

"X". "ILLEGAL FUNCTION CALL" If no

line "X".

If deletion 1s performed, all variable values are lost.

Also continuing 1s not allowed, and all "F0R"s and "G0SUB"s

are made Inactive. (This 1s the same effect caused when-

ever a program 1s modified.)

DELETE Y-X

LIST X

LIST or LIST-

LIST X-

LIST -X

LIST Y-X

Lists Hne "X" 1f there Is one.

Lists the entire program.

Lists all lines in a program with a

Hne number equal to or greater than

"X".

Lists all of the lines 1n a program

with a Hne number less than or equal

to "X".

Lists all of the lines within a pro-

gram with Hne numbers equal to or

greater than "Y", and less than or

equal to "X".

EXAMPLE PURPOSE/USE

ERASE J% Eliminates an array. If no such

array exists an "ILLEGAL FUNCTION

ERASE

XX,

I# CALL" error will occur. ERASE must

refer to an array, not an array ele-

ERASE A$ ment [ERASE B(9) would be Illegal].

The space the array Is using 1s freed

ERASE D#,NMSX up and made available for other uses.

The array can be dimensioned again,

but the values before the ERASE are

lost.

Exchanges the value of two variables.

(If X=1 & Y=5, after SMAP X,Y the

values would be switched; that 1s,

now X=5 & Y=l.) Both, one or neither

of the variables may be array elements.

If a non-array variable that has not

been assigned a value Is referenced

an "ILLEGAL FUNCTION CALL" error will

occur. Both variables must be of

the same type (both Integers, both

strings, both double precision or

both single precision), otherwise a

"TYPE MISMATCH" error will occur.

TRON Turns on the trace flag.

TROFF Turns off the trace flag.

TRON & TROFF can be given In either

direct or Indirect (program) mode.

When the trace flag Is on, each time

a new program line Is started, that

line number 1s printed enclosed 1n

"[]". No spaces are printed. For

example:

SMAP IX,JX

SWAP B$(7),T$

SWAP D#(I),D#(I+1)

TRON

10 PRINT 1: PRINT "A"

20 STOP

RUN

DO] 1

[20]

BREAK IN 20

"NEW" will also turn off the trace

flag along with Its other functions.

STATEMENTS

IF-THEN-ELSE (Similar to 8K version IF-THEN state-

ment, only with the addition of a new

"ELSE" clause.)

IF X>Y THEN PRINT "GREATER" ELSE PRINT "NOT GREATER"

In the above example, first the

relational condition would be tested.

If it is true, the THEN clause would

be executed ("GREATER" would be

printed). If it is false, the ELSE

clause would be executed ("NOT GREATER"

would be printed).

10 IF A>B THEN PRINT "A>B" ELSE IF B>A THEN PRINT "B>A" ELSE PRINT "A=B"

The above example would indicate

which of the two variables was the

largest, or if they were equal.

As this example indicates, IF state-

ments may be nested to any desired

level (regulated only by the maximum

line length). An IF-THEN-ELSE state-

ment may appear anywhere within a mul-

tiple-statement Hne; the THEN clause

being always mandatory with each IF

clause and the ELSE clause optional.

Care must be taken to insure that IFs

without ELSE clauses do not cause an

ELSE to be associated with the wrong

IF.

5 IF A=B THEN IF A=C THEN PRINT "A=C ELSE PRINT "A<>C" ELSE PRINT "A<>B"

In the above example, the double

under-lined portion of the line is

an IF-THEN-ELSE statement which is

all a part of the THEN clause of the

first IF statement in the line. The

second ELSE (single under-lined) is

part of the first IF, and will be

executed only if the first relational

expression is false (A<>B). If a

line does not contain the same number

of ELSE and THEN clauses, the last

ELSE is matched with the closest THEN.

TYPING

Normally, numbers used In BASIC operations are stored and acted upon as single

precision floating point numbers. This allows for 7 digits of accuracy.

In the extended version of BASIC greater accuracy may be obtained by typing

numbers as double precision. This allows for 16 digits of accuracy. In

cases where speed is critical, it is, however, slower than single precision.

The greatest advantage, in both speed and storage space can be obtained by using

integer operations whenever possible. These fall within the rage <=32767 to

>=-32768.

Examples:

(single precision) PRINT 1/3

.3333333

(double precision) PRINT 1/3D

.3333333333333333

(integer) PRINT 1/3%

PRINT 2.76%

The use of these types of numbers will become clearer further on in the

text.

Examples:

I%(10) uses (11 * 2) + 6 + (2 * 1) = 30

I (5,5) uses (6 * 6 * 4) + 6 + (2 * 2) = 154

TYPING

There are four types of values used 1n EXTENDED BASIC programming:

NAME SYMBOL # OF BYTES/VALUE

STRINGS (0 to 255 $ 3

characters)

INTEGERS (must be % 2

-32768 and =<

32767)

DOUBLE PRECISION # 8

(exponent: -38

to +38) 16 digits

SINGLE PRECISION ! 4

(exponent: -38

to +38) 7 digits

The type a variable will be is explicitly declared by using one of the

four symbols listed above. Otherwise, the first letter of the variable is

used to look into the table that indicates the default type for that letter.

Initially (after CLEAR, after RUN, after NEW, or after modifying a program)

all letters are defaulted to SINGLE PRECISION.

The following four statements can be used to modify the DEFAULT table:

STATEMENT DEFAULTS VARIABLE TO

DEFINT r INTEGER

DEFSTRr STRING

DEFDBL r DOUBLE PRECISION

DEFSNG r SINGLE PRECISION

r above indicates the position for the range to be given. This

is to be of the following format: letter or letter 1 - letter 2.

(In the second format, the "-" indicates from letter 1 through

letter 2 inclusive.)

In the above four statements the default type of all of the letters within

the range is changed, depending on which DEF "type" is used. Initially,

DEFSNG A-Z is assumed. Care should be taken when using these statements

since variables referred to without type indicators may not be the same after

the statement is executed. It is recommended that these statements be used

only at the start of a program, before any other statements are executed.

The following will illustrate some of the above information:

10 I%=1

20 n=2 The example on the left would

30 I#=3 print out:

40 I$="ABC" 2 at line # 50

50 PRINT 1 1 at line # 70

60 DEFINT 1 ABC at line # 90

70 PRINT 1 3 at Hne # 110

80 DEFSTR 1

90 PRINT 1

100 DEFDBL 1

110 PRINT 1

TYPING OF CONSTANTS

The type that a particular constant will be is determined by the following:

1) if it is more than 7 digits or "D" is used in the exponent,

then it will be DOUBLE PRECISION.

2) if it is >32767 or <-32768, a decimal point (.) is used,

or an "E" is used, then it is SINGLE PRECISION.

3) otherwise, it is an integer.

When a + or * operation or a comparison is performed, the operands are

converted to both be of the same type as the most accurate operand. There-

fore, if one or both operands are double precision, the operation is done

in double precision (accurate but slow). If neither is double precision

but one or more operands are single precision floating point, then the

operation will be done in single precision floating point. Otherwise,

both operands must be integers, and the operation is performed in integer

representation.

If the result of an integer + or * is too big to be an integer, the oper-

ation will be done in single precision and the result will be single preci-

sion. Division (/) is done the same as the above operator, except it is never

done at the integer level. If both operands are integers, the operation is

done as a single precision divide.

The operators AND, OR, NOT, \, and MOD force both operands to be integers

before the operation is done. If one of the operands is >32767 or <-32768, an

overflow error will occur. The result of these operators will always be an

integer. (Except -32768\-l gives single precision.)

No matter what the operands to + are, they will both be converted to single

precision. The functions SIN, COS, ATN, TAN, SQR, LOG, EXP, and RND also

convert their arguments to single precision and give the result as such, ac-

curate to 6 digits.

Using a subscript >32767 and assigning an integer variable a value too

large to be an integer gives an overflow error.

TYPE CONVERSION

When a number Is converted to an integer, it is truncated (rounded down).

For example:

I%=.999 A%=-.01

PRINT 1% PRINT A%

0 -1

It will perform as if the INT function was applied.

When a double precision number is converted to single precision, it is

rounded off. For example:

D#=77777777

I!=D#

PRINT I!

7.77778E+07

No automatic conversion is done between strings and numbers. See the STR$,

NUM, ASC, and CHR$ functions for this purpose.

NEW FUNCTIONS

CINT Convert the argument to an integer number

CSNG Convert the argument to a single precision number

CDBL Convert the argument to a double precision number

Examples: CDBL(3)=3D

CINT(3.9)=3

CINT(-.01)=-1

CSNG(312456.8)=312457

NOTE: if X<=32767 and =>-32768 then CINT(X)=INT(X)

otherwise, CINT will give an overflow error

NEW OPERATORS

\(backslash=shift L)

Integer Division

Examples: 1\3=0

7\2=3

-3\-l=3

300\7=42

-8\3=-2

-1\3=0

The integer division operator forces

both arguments to integers and gives

the integer value of the division

operation. (The only exception to this

is -37268\-l, which results in a value

too l*arge to be an integer.)

NOTE: A\B does not equal INT(A/B)

(if A=-l & B=7, 0 does not

equal -1)

Integer division is about eight times

as fast as single precision division.

Its precedence is just below that of

*&/.

NEW OPERATORS (cont.J

MOD The MOD operator forces both arguments

to integers and returns a result

according to the following formula:

Examples: 4 MOD 7=4

13 MOD 3=1

7 MOD -11=7 A MOD B = A - [B * (A\B)]

-6 MOD -4=-2 If B=0 then a division by zero error

will occur. MODs precedence is just

below that of integer division and

just above + and -.

USER-DEFINED-FUNCTIONS

In the Extended version of BASIC, a user-defined function can be of any

type and can take any number of arguments of any type.

The result of the function will be forced to the function type before

the value is substituted into the formula with the function call.

The loop variable in a FOR loop can be an integer as well as a single

precision number. Attempting to use a string or double precision vari-

able as the loop variable will cause a Type Mismatch error to occur.

Integer FOR loops are about three times as fast as single precision FOR

loops. If the addition of the increment to the loop variable gives a

result that is too big to be an integer, an overflow error will occur. The

initial loop value, increment value and the final value must all be in the

legal range for integers or an overflow error will occur when the FOR is

executed.

Examples: DEF FNRAND0M%=10*RND(1)+1

DEF FNTW0$(X$)=X$+X$

DEF FNA(X,Y,Z,I%)=X+Z+I%*Y

FOR LOOPS (Integer)

Example: 1 FOR I%=20000 TO 30000 STEP 20000

2 PRINT 1%

3 NEXT 1%

RUN

20000

OVERFLOW IN 3

These messages replace the old error messages listed In APPENDIX C (p. 53)

the BASIC manual.

NEXT WITHOUT FOR

SYNTAX ERROR

RETURN WITHOUT GOSUB

OUT OF DATA

ILLEGAL FUNCTION CALL

OVERFLOW

OUT OF MEMORY

UNDEFINED STATEMENT

SUBSCRIPT OUT OF RANGE

REDIMENSIONED ARRAY

DIVISION BY ZERO

ILLEGAL DIRECT

TYPE MISMATCH

OUT OF STRING SPACE

STRING TOO LONG

STRING FORMULA TOO COMPLEX

CAN'T CONTINUE

UNDEFINED USER FUNCTION

Examples: 10 GOTO 50

RUN

UNDEFINED STATEMENT IN 50

PRINT 1/0

DIVISION BY ZERO

ADDITIONAL NOTES ON EXTENDED BASIC

PEEK & POKE In the 8K version of BASIC you can't PEEK at or POKE

Into memory locations above 32767. In the Extended

version this can be done by using a negative argument.

If the address to be PEEKed or POKEd is greater than

32767, subtract 65536 from it to give the proper

argument.

Examples: to PEEK at 65535 PEEK(-l)

to POKE at 32768 POKE -32768,1%

INT The INT function will work on numbers both

single & double precision which are too large to

be integers. Double precision numbers maintain

full accuracy, (see CINT)

Examples: 1NT(1E38)=1E38

INT(123456789.6)=123456789

ADDITIONAL NOTES (cont.) (miscellaneous)

Extended BASIC uses 10.2K of memory to reside.

String space is defaulted to 100 in the Extended version.

A comma before the THEN in an IF statement is allowed.

USR pass routine [4,5] passes in [H,L] not [D,E], and the pass back routine

[6,7] receives in [H,LJ not [A,B].

Files CSAVEd in 8K BASIC cannot be CLOADed in EXTENDED BASIC, nor the opposite.

UPDATE TO EXISTING MATERIAL

In cassette BASICs (both 8K* and Extended), CLOAD? some character file name,

reads the specified file and checks it against the file in core. If the

files do not match, the message "NO GOOD" is printed. If they do match,

BASIC returns to command level and prints "OK".

In the Extended version of BASIC, active FOR loops (integer or single

precision) require 17 bytes.

Each non-array ["string Ivariable uses [*6"1 bytes.

integer 5

double 11

precision

single

precision

This is because, it takes 3 bytes to store the name of a vari-

able.

Each array uses: (# of elements)*

Examples:

"INT=2

DBL=8

STR=3

SNG=4

+6+2*(# of dimensions).

I%(_10) uses (ll*2)+6+(2*l)=30 bytes

1(5,5) uses (6*6*4)+6+(2*2)=154 bytes

Stored programs take exactly the same amount of space as in the 8K version of

BASIC, except the reserved word ELSE takes 2 bytes instead of 1 byte as with

the other reserved words.

UPDATE TO EXISTING MATERIAL

(Applies to 8K versions 3.2 and later.)

In both Extended & 8K* BASIC, if a number is between >=lE-2 and <1E-1,

the number will be printed as:

.OXXXXXX (trailing zeros suppressed)

instead of X.XXXXXXE-2

An 8K BASIC program should run exactly the same under Extended BASIC.

No conversion should be necessary.

USRLOC in extended is:

101 octal=65 decimal,

still 111 in 8K and 4K to load.

EXTENDed:

(Non-disk) location 002 in the BOOT

should be 57 (8K=37, 4K=17)

UPDATE TO EXISTING MATERIAL

(Applies to page 57 of version 3.2 and later.)

Each active GOSUB takes 5 bytes.

Each active FOR loop takes 16 bytes.

EDIT COMMAND

The EDIT command Is for the purpose of allowing modifications and additions

to be made to existing program lines without having to retype the entire

line each time.

Commands typed in the EDIT mode are, as a rule, not echoed. Most commands

may be preceded by an optional numeric repetition factor which may be used

to repeat the command a number of times. This repetition factor should be

in the range 0 to 255 (0 is equivalent to 1). If the hepetition factor is

omitted, it is assumed to be 1. In the following examples a lower case

"n" before the command stands for the repetition factor.

In the following description of the EDIT commands, the "cursor" refers to

a pointer which is positioned at a character in the Hne being edited.

To EDIT a Hne, type EDIT followed by the number of the Hne and hit the

carriage return. The Hne number of the Hne being EDITed will be printed,

followed by a space. The cursor will now be positioned to the left of

the first character in the Hne.

NOTE: The best way of getting the "feel" of the EDIT command is to try

EDITing a few lines yourself. Commands not recognized as part of

the EDIT commands will be ignored.

MOVING THE CURSOR

A space typed in will move the cursor to the right and cause the character

passed over to be printed out. A number preceding the space (nS) will

cause the cursor to pass over and print out the number (n) df characters

chosen.

INSERTING CHARACTERS

I Inserts new characters into the Hne being edited. After the

I is typed, each character typed in will be inserted at the

current cursor position and typed on the terminal. To stop

inserting characters, type "escape" (or Alt-<-mode on some ter-

minals).

If an attempt is made to insert a character that will make

the Hne longer than the maximum allowed (72 characters),

a bell will be typed (control G) on the terminal and the

character will not be inserted.

WARNING: It is possible using EDIT to create a Hne which,

when listed with its Hne number, is longer than

72 characters. Punched paper tapes containing such

lines will not be read in properly. However, such

lines may be CSAVEd and CLOADed without error.

A backarrow (or underline) typed during an insert command will

delete the character to the left of the cursor. Characters

up to the beginning of the line may be deleted in this manner,

and a backarrow will be echoed for each character deleted.

However, if no characters exist to the left of the cursor, a

bell 1s echoed instead of a backarrow.

If a carriage return is typed during an insert command, it

will be as if an escape and then carriage return was typed.

That is, all characters to the right of the cursor will be

printed and the EDITed line will replace the original line.

X is the same as I, except that all characters to the right

of the cursor are printed, and the cursor moves to the end

of the line. At this point it will automatically enter the

insert mode (see I command).

X is very useful when you wish to add a new statement to the

end of an existing line. For example:

Typed by User EDIT 50 (carriage return)

Typed by ALTAIR 50 X=X+1:Y=Y+1

Typed by User X :Y=Y+1 (carriage return)

In the above example, the original line #50 was:

50 X=X+1

The new EDITed line #50 will now read:

50 X=X+1:Y=Y+1

H is the same as I, except that all characters to the right

of the cursor are deleted (they will not be typed). The insert

mode (see I command) will then automatically be entered.

H is most useful when you wish to replace the last statements

on a line with new ones.

DELETING CHARACTERS

nD deletes n number of characters to the right of the cursor. If

less than n characters exist to the right of the cursor, only that

many characters will be deleted. The cursor is positive to the

right of the last character deleted. The characters deleted are

enclosed in backslashes (\). For example:

Typed by User 20 X=X+1:REM JUST INCREMENT X

Typed by User EDIT 20 (carriage return)

Typed by ALTAIR 20 \X=X+1:\REM JUST INCREMENT X

Typed by User 6D (carriage return)

The new line #20 will no longer contain the characters which

are enclosed by the backslashes.

SEARCHING

S The nSy command searches for the n^ occurance of the character

y in the Hne. The search begins at the character one to the

right of the cursor. All characters passed over during the

search are printed. If the character is not found, the cursor

will be at the end of the Hne. If it is found, the cursor will

stop at that point and all of the characters to its left will

have been printed.

For example:

Typed by User 50 REM INCREMENT X

Typed by User EDIT 50

Typed by ALTAIR 50 REM INCR

Typed by User 2SE

nt^y is equivalent to S, except that all of the characters

passed over during the search are deleted. The deleted char-

acters are enclosed in backslashes. For example:

Typed by User 10 TEST LINE

Typed by User EDIT 10

Typed by ALTAIR 10 \TEST\

Typed by User KL

TEXT REPLACEMENT

C A character in a Hne may be changed by the use of the C command.

Cy, where y is some character, will change the character to the

right of the cursor to y. The y will be typed on the terminal

and the cursor will be advanced one position. nCy may be used

to change n number of characters in a Hne as they are typed in

from the terminal. (See example below.)

If an attempt is made to change a character which does net exist,

the change mode will be exited.

Example:

Typed by User 10 FOR 1=1 TO 100

Typed by User EDIT 10

Typed by ALTAIR 10 FOR 1=1 TO 256

Typed by User 2S1 3C256

ENDING AND RESTARTING

Carriage Return Tells the computer to finish editing and print the re-

mainder of the Hne. The edited Hne replaces the original

Hne.

E E is the same as a carriage return, except the remainder

of the Hne is not printed.

Q Quit. Changes to a line do not take effect until an E

or carriage return is typed. Q allows the user to restore

the original line without any changes which may have been

made, if an E or carriage return has not yet been typed.

"OK" will be typed and BASIC will await further commands.

L Causes the remainder of the line to be printed, and then

prints the line number and restarts EDITing at the beginning

of the line. The cursor will be positioned to the left of the

first character in the line.

L is most useful when you wish to see how the changes in a line

look so that you can decide if further EDITs are necessary.

Example:

Typed by User EDIT 50

Typed by ALTAIR 50 REM INCREMENT X

Typed by User 2SM L

Typed by ALTAIR 50

Causes the original copy of the line to be restored, and EDITing

to be restarted at the beginning of the line. For example:

Typed by User 10 TEST LINE

Typed by User EDIT 10

Typed by ALTAIR 10 \TEST LINE\

Typed by User 10D A

Typed by ALTAIR 10

In the above example, the user made a mistake when he deleted

TEST LINE. Suppose that he wants to type "ID" instead of "10D"

By using A command, the original line 10 is reentered and is

ready for further EDITing.

IMPORTANT

Whenever a SYNTAX ERROR is discovered during the execution of a source

program, BASIC will automatically begin EDITing the line that caused the

error as if an EDIT command had been typed. For Example:

10 APPLE

RUN

SYNTAX ERROR IN 10

Complete editing of a line causes the line edited to be re-inserted.

Re-inserting a line causes all variable values to be deleted, therefore

you may want to exit the EDIT command without correcting the line so that

you can examine the variable values.

This can be easily accomplished by typing the Q command while in the EDIT

mode. If this is done, BASIC will type OK and all variable values will

be preserved.

PRINT USING

The PRINT USING statement can be employed in situations where a specific

output format is desired. This situation might be encountered in such

applications as printing payroll checks or an accounting report. Other

uses for this statement will become more apparent as you go through the

text.

The general format for the PRINT USING statement is as follows:

(line number) PRINT USING <string>; <value list>

The "string" may be either a string variable, string expression or a string

constant which is a precise copy of the line to be printed. All of the char-

acters in the string will be printed just as they appear, with the exception

of the formatting characters. The "value list" is a list of the items to

be printed. The string will be repeatedly scanned until: 1) the string ends

and there are no values in the value list 2) a field is scanned in the string,

but the value list is exhausted.

The string should be constructed according to the following rules:

STRING FIELDS

! Specifies a single character string field. (The string itself

is specified in the value list.)

\n spaces\ Specifies a string field consisting of 2+n characters. Backslashes

with no spaces between them would indicate a field of 2 characters

width, one space between them would indicate a field 3 characters

in width, etc.

In both cases above, if the string has more characters than the field width,

the extra characters will be ignored. If the string has less characters

than the field width, extra spaces will be printed to fill out the entire

field.

Trying to print a number in a string field will cause a TYPE MISMATCH error

to occur.

Example: 10 A$="ABCDE":B$="FGH"

20 PRINT USING "!";A$,B$

30 PRINT USING "\ \";B$,A$

(the above would print out)

FGHABCD

Note that where the "!" was used only the first letter of each string was printed.

Where the backslashes were enclosed by two spaces, four letters from each string

were printed (an extra space was printed for B$ which has only three characters).

The extra characters in the first case and for A$ in the second case were ignored.

NUMERIC FIELDS

With the PRINT USING statement, numeric prin-outs may be altered to suit almost

any applications which may be found necessary. This should be done according

to the following rules:

# Numeric fields are specified by the # sign, each of which will

represent a digit position. These digit positions are always

filled. The numeric field will be right justified; that is,

if the number printed is too small to fill all of the digit

positions specified, leading spaces will be printed as necessary

to fill the entire field.

The decimal point position may be specified in any particular

arrangement as desired; rounding is performed as necessary.

If the field format specifies a digit is to precede the decimal

point, that digit will always be printed (as 0 if necessary).

The following program will help illustrate these rules:

10 INPUT A$,A

20 PRINT USING A$;A

30 GOTO 10

RUN

? ##,12

? ###,12

? #####,12

?##.##,12

IB. 00

? ###.,12

IB.

? #.###,.02

O-OEO

? ##.#,2.36

E-4

t This sign may be used at either the beginning or end of the

numeric field, and will force the + sign to be printed at

either end of the field as specified, if the number is positive.

If it is used at the end of the field, and the number is negative,

a -sign will be forced at the end of the number.

The - sign when used at the end of the numeric field designation

will force the sign to be printed trailing the number, If it is

negative. If the number 1s positive, a space is printed.

NOTE: There are cases where forcing the sign of a number to

be printed on the trailing side will free an extra space

for leading digits. (See exponential format.)

** The ** placed at the beginning of a numeric field designation will

cause any unused spaces in the leading portion of the number

printed out to be filled with asterisks. The ** also specifies

positions for 2 more digits. (Termed "asterisk fill")

$$ When the $$ is used at the beginning of a numeric field designation,

a $ sign will be printed in the space immediately preceding the

number printed. Note that the $$ also specifies positions for

two more digits, but the $ itself takes up one of these spaces.

Exponential format cannot be used leading $ signs, nor can nega-

tive numbers be output unless the sign is forced to be trailing.

**$ The **$ used at the beginning of a numeric field designation

causes both of the above (** & $$) to be performed on the number

being printed out. All of the previous conditions apply, except

that **$ allows for 3 additional digit positions, one of which is

the $ sign.

, A comma appearing to the left of the decimal point in a numeric

field designation will cause a comma to be printed every three

digits to the left of the decimal point in the number being

printed out. The comma also specifies another digit position.

A comma to the right of the decimal point in a numeric field de-

signation is considered a part of the string itself and will be

treated as a printing character.

tTTT Exponential Format. If the exponential format of a number is

desired in the print out, the numeric field designation should

be followed by tTTT (allows space for E±XX). As with the other

formats, any decimal point arrangement is allowed. In this case,

the significant digits are left justified and the exponent is

adjusted.

% If the number to be printed out is larger than the specified numeric

field, a % character will be printed and then the number itself

in its standard format. (The user will see the entire number.)

If rounding a number causes it to exceed the specified field,

the % character will be printed followed by the rounded number.

(Such as field= .##, and the number is .999 will print % 1.00.)

If the number of digits specified exceeds 24, a FUNCTION CALL error will occur.

Try going through the following examples to help illustrate the preceding

rules. A single program such as follows is the easiest method for learning

PRINT USING.

Examples: Type the short program into your machine as it is

listed below. This program will keep looping and

allow you to experiment with PRINT USING as you

go along.

Program: 10 INPUT A$,A

20 PRINT USING A$;A

30 GOTO 10

RUN

The computer will start by typing a ?. Fill in the numeric

field designator and value list as desired, or follow along

below.

?+#,9

?+#,io

X+10

?##,-2

-B

?+#,-2

-3

?#,-2

X-3

?+.###,.02

+ .030

? ####.#,100

100.0

?##+,2

? THIS IS A NUMBER ##,2

THIS IS A NUMBER 3

? BEFORE ## AFTER,12

BEFORE 13 AFTER

? ####,44444

xnnmm

?**##,i

? **##,12

**1B

? **##,123

*1B3

? **##,1234

1334

? **##,12345

X13345

?**,1

?**,22

? **.##,12

13-00

? **####,l

****m

(note: not floating $)

(note: floating $)

? $####.##,12.34

3 IE.34

? $$####.##,12.56

eiB.sb

? $$.##,1.23

31. E3

? $$.##,12.34

X31E-34

? $$###,0.23

? $$####.##,0

30-00

? **$###.##,1.23

****31.E3

? **$.##,1.23

*31.E3

?**$###,l

****$!

?#,6.9

?#.#,6.99

7.0

?##-,2

? ##-,-2

E-

?##+,2

E+

? ##+,-2

E-

? ##tttt,2

BE+00

? ##tttt,12

1E+01

? #####.###TTtT,2.45678

B45b.?a0E-03

? #.###tttt,123

0.1E3E+03

? #.##tttt,-123

--1EE+03

? #####,###.#,1234567.89

lnE34nS!3?.T

APPENDIX A SUPPLEMENT

HOW TO LOAD BASIC

For BASIC versions 3.2 and later, the load procedure has been updated to

allow the use of the new I/O boards (2SI0 & 4PI0), the old 88-PIO board,

and more general channel assignments.

Location 001 of the bootstrap loaders listed in APPENDIX A must be changed

from 175 to 256 to load BASIC versions 3.2 and later. For the older ver-

sions of BASIC, the location should be left at 175.

For EXTENDED BASIC, location 002 (set at 017 for 4K & 037 for 8K) should

be set at 057.

The checksum loader has a new error message "M" which indicates that the

data that was loaded into memory did not read back properly (see step 22

on page 50 of APPENDIX A). Loading into non-existent, protected or mal-

functioning memory can cause this to occur. The new error message will

also be sent repeatedly, instead of only once. The message is sent on

channels 1, 21 and 23; so, if no terminal device is on one of these three

channels, the panel lights must be examined to see if a checksum error has

occured.

Error Detection

The new checksum loader (BASIC versions 3.2 & later) will display X7647

on the address lights when running properly. (X above will be 0 for 4K

BASIC, 1 for 8K or 2 for EXTENDED.)

When an error occurs (checksum "C"-bad tape data, memory "M"-data won't

store properly, overlay "0"-attempt to load over top of the checksum

loader) the address lights will then display X7637. The ASCII error

code will be stored in the accumulator (A).

More simply, A5 should be on with A4 & A3 off during proper loading.

When an error occurs, A5 will turn off and A4 & A3 will turn on.

Load Options

OCTAL STATUS BITS

LOAD DEVICE SWITCHES UP CHANNELS ACTIVE

SIOA,B,C (not REV 0) none 0,1 low

ACR Al5(and 6,7 low

terminal opts)

SIOA,B,C (REV 0) A14 0,1 high

OCTAL

MASKS

1/200

40/2

88-PIO A13 0,1 high 2/1

4PIO A12 20,21 high 100/100

2SIO All(andA10 20,21 high 1/2

up=lstop bit

down=2 stop bits) ay

There are six different bootstrap loaders, one for each of the six types

of I/O boards listed in the Load Option chart. Be sure that you use the

correct one for your particular board.

If the load device is an ACR, the Terminal Options (see second chart)

can be set in the switches (along with A15) before the loading is done.

If A15 is set, the checksum loader will ignore all of the other switches

and BASIC will ignore A15.

If the load device and the terminal device are not the same, and the load

device is not an ACR, then only the load options should be set before the

loading. When the load completes, BASIC will start-up and try to send a

message to the load device. STOP BASIC, EXAMINE LOCATION 0, SET THE TER-

MINAL OPTION SWITCHES, AND THEN DEPRESS RUN.

If the initialization dialog hasn't completed, everytime BASIC is restarted

at zero, it will examine the sense switches and reconfigure the terminal

input/output options. Once the initialization dialog is complete, the

sense switches are no longer examined and the I/O configuration is fixed

until BASIC is reloaded.

Terminal Options

TERMINAL DEVICE

SIOA,B,C (not REV 0)

SIOA,B,C(REVO)

88-PIO

4PIO

2SIO

SWITCHES UP

none

A14

A13

A12

All

OCTAL CHANNEL DEFAULT

0,1

20,21 (INPUT)

22,23 (OUTPUT)

20,21 (A10 up=l stop bit

down=2 stop bits)

The default channels listed above may be changed as desired by raising

A8 and storing the lowest channel number (Input flag channel) in one

of the following locations: 7777 (octal) for 4K BASIC

17777 (octal) for 8K BASIC

27777 (octal) for EXTENDED BASIC

(non-disk version)

NOTE: The "Input flag channel" may also be refered to as the "control

channel" in other ALTAIR documentation.

The above information is useful only when the load device and terminal

device are not the same. During the load procedure A8 will be ignored;

therefore, the board from which BASIC is loaded must be strapped for the

channels listed in the Load Option chart.

The following page contains three new bootstrap loaders for the 88-PIO,

4PIO and 2SIO boards. The conditions for using the other loaders listed

in APPENDIX A are given at the beginning of this supplement.

88-PIO (for versions 3.2 & later only)

OCTAL ADDRESS OCTAL CODE

000 041

001 256

002 017 (for 4K, 037 for 8K, 057 for EXTENDED)

003 061

004 023

005 000

Q06 333

007 000

010 346 NOTE: Switch A13 should be up;

011 040 88-PIO should be strapped

012 310 for channels 0,1.

013 333

014 001

015 275

016 310

017 055

020 167

021 300

022 351

023 003

024 000

2SIO (for

versions 3.2 & later only)

OCTAL ADDRESS OCTAL CODE OCTAL ADDRESS OCTAL CODE

000 076 030 300

001 003 031 351

002 323 032 013

003 020 033 000

004 076

005 021 (=2 stop bits

006 323 025

=1 stop bit)

007 020

010 041

011 256

012 017 (for 4K, 037 for 8K, 057 for EXTENDED)

013 061

014 032

015 000 NOTE: Switch All should be up;

016 333 If the 2SIO also is the

017 020 terminal device, set A10

020 017 up for 1 stop bit or down

021 320 for 2 stop bits. The 2SIO

022 333 should be strapped for

023 021 channels 20,21.

024 275

025 310

026 055

027 167

4PI0 (for versions 3.2 & later only)

OCTAL ADDRESS OCTAL CODE

000 257

001 323

002 020

003 000

004 323

005 021

006 076

007 004

010 323

011 020

012 041

013 256

014 017 (for 4K, 037 for 8K, 057 for EXTENDED)

015 061

016 035

017 000

020 333 NOTE: Switch A12 should be up.

021 020

022 346

023 100

024 310

025 333

026 021

027 275

030 310

031 055

032 167

033 300

034 351

035 015

036 000

The following three programs are echo programs for the 88-PIO, the 4PIO

and the 2SI0 boards.

If you wish to test a device that does Input only, dump the echoed

characters on a faster device or store them in memory for examination.

For an Output only device, send the data in the sense switches or some

constant for the test character. Make sure to check the ready-to-receive

bit before doing output.

If the echo program works, but BASIC doesn't; make sure the load device's

UART is strapped for 8 data bits and that the ready-to-receive flag gets

set properly on the terminal device.

100

ECHO PROGRAMS:

88-PIO

OCTAL ADDRESS OCTAL CODE OCTAL ADDRESS OCTAL CODE

000 333 007 333

001 000 010 001

002 346 Oil 323

003 040 012 001

OM 312 013 303

005 000 014 000

006 000 015 000

2SIO

OCTAL ADDRESS

000

001

002

003

004

005

006

007

010

011

012

OCTAL CODE

076

003

323

020 (flag ch.)

076

021(lst. bt.,

323 025 for 2)

020

333

020

017

OCTAL ADDRESS

013

014

015

016

017

020

021

022

023

024

OCTAL CODE

322

010

000

333

021 (data ch.)

323

021

303

010

000

4PIO

OCTAL ADDRESS OCTAL CODE OCTAL ADDRESS OCTAL CODE

000 257 024 312

001 323 025 020

002 020 026 000

003 323 027 333

004 021 030 022

005 323 031 346

006 022 032 100

007 057 033 312

010 323 034 027

Oil 023 035 000

012 076 036 333

013 OM 037 021

014 323 040 323

015 020 041 023

016 323 042 303

017 022 043 020

020 333 044 000

021 020

022 346

023 100 101

24SO Alamo SB

Albuquerque, NM 87106

88-4MCS

PARTS LIST

.APRIL, 1976

2 741300 101069 5 6-32 x 3/8" Screw 100925

1 74LS04 101042 1 #6-32 Nut 100933

3 74LS13 101124 1 #6 Lock Washer 100942

2 74LS14 101123 1 Heat Sink (Large) 101870

2 74367 101040 2 Ferrite Beads 101876

1 7805 101074

BAG 7

BAG 2 34 16 Pin Socket 102103

32 2102A-4 101107 8 14 Pin Socket 102102

1 Dip Switch (4-SPDT) 102321

2 Card Guides 101714

BAG 3 1 100 Pin Connector 101864

42 .IMF 12-16V 100348 MISC.

BAG 4 1 P.C. Board 1O0187

1 4MCS Manual 101533

2 .01MF 16V-1KV 100321

1 IMF 20V 100325

3 33MF 16V 100326

BAG 5

1 4 Ohm 3W 10% 102007

32 2102A-4 101107

BAG 3

42 .IMF 12-16V 100348

BAG 4

2 .01MF 16V-1KV 100321

1 IMF 20V 100325

3 33MF 16V 100326

BAG 5

1 4 Ohm 5W 10% 102007

2 100 0hm.%WlQ% 101924

2 2.2K %W 10% 101945

BAG 6

5 6-32 x 3/8" Screw

1 #6-32 Nut

1 #6 Lock Washer

1 Heat Sink (Large)

2 Ferrite Beads

100925

100933

100942

101870

101876

BAG 7

34 16 Pin Socket

8 14 Pin Socket

1 Dip Switch (4-SPDT)

2 Card Guides

1 100 Pin Connector

102103

102102

102321

101714

101864

MISC.

P.C. Board

4MCS Manual 1O0187

101533

Altair_8800_BASIC_Reference_Manual_1975 BASIC Manual 75

Navigation menu

Versions of this User Manual:

Views

Navigation