MORE BASIC INFO

Topics
CONSTRESTORE
LPRINTSELECT CASE
RNDWHILE ... WEND
Integer FunctionsEXIT (Four Uses)
STATICAligning Print Data
Main Basic Page

Here is additional information about Basic not included in the lessons.

CONST

The command CONST allows you to name constants. The command

CONST pi = 3.14159

tells Basic that pi is a constant with the value 3.14159. If later in the program you want to compute the area of a circle of radius R, you can use a statement like

A = pi * R * R.

If you want to use double precision in the constant pi, write

CONST pi = 3.1415926536# .

If you do not specify the type after a constant, Basic will sometimes make an intelligent guess to specify a type for you. A constant can be defined also as a string, such as

CONST myname = "Don Ho" .

Once a constant is defined, you cannot perform operations in the program that change the constant. For instance, if you define pi as 3.14159 and later add the statement

pi = pi + 2 ,

you will get an error message.

LPRINT

The command LPRINT works exactly like PRINT, except that printing is directed to the printer instead of the screen. The statement

LPRINT "The solution of the equation is"; X

gives printing instructions to the printer connected to your computer. The output appears on paper exactly as it would on the screen if LPRINT were changed to PRINT. You can use the USING command also with LPRINT, as in

LPRINT USING "Your refund is $$####.##"; R

(The letter L before print comes from the phrase "line printer", used in the old days to refer to the printer connected to the computer.)

RND

This command returns a single precision random number between 0 and 1 However, the number is not truly random - to make it random place the command

RANDOMIZE TIMER

somewhere before the RND statement. The sequence of commands

RANDOMIZE TIMER
X = RND
M = INT(RND * N) + 1

produces a random number X between 0 and 1, and a random integer M from 1 to N.

Integer Functions

Here are four functions related to integers:

INT(X) = largest integer less than or equal to X
FIX(X) = whole number part of X (drops the part to the right of the decimal point)
CINT(X) = closest integer to X (rounds X to the closest integer)
CLNG(X) = closest long integer to X (handles bigger numbers than CINT)

Examples :

INT (2.4) = 2 FIX (3.9) = 3 CINT (2.3) = 2
INT (5) = 5 FIX (6) = 6 CINT (8.54) = 9
INT (-3.72) = - 4 FIX (-7.21) = - 7 CINT (-1.72) = - 2

STATIC

A main program might call a subprogram (or a function subprogram) more than once, or even many times. Ordinarily a subprogram will not remember the values of all its variables between runs. Variables that do not appear in the CALL statement or that are not shared with the main program are automatically set to zero every time the subprogram begins a run. (The same is true for the main program - if you run it once and then a second time, at the beginning of the second run all variables are reset to the default value zero.)

But sometimes it is necessary that a subprogram remember the values of some or all of its variables from one run to another. For example, if the subprogram has a print counter P, counting the number of times the subprogram prints something, then you will not want P to reset to zero each time the subprogram is called, but rather you will want P to retain its value between the end of one run to the beginning of the next run. A variable in a subprogram having this property is called a static variable.

The STATIC statement is used to make variables static - that is, it forces variables to preserve their values from one run of a subprogram to the next. If you place the word STATIC at the end of the first line of a subprogram procedure, or of a function subprogram, then all variables in the subprogram are static. Here are examples:

SUB Poly (N,X) STATIC
DEF FNA (X) STATIC

If you want only certain variables in the subprogram to be static, you may insert a STATIC statement within the subprogram to accomplish this. The statement

STATIC X

makes X a static variable in a subprogram, while the statement

STATIC Y, A()

makes Y a static variable and A a static array. (The array must be followed by empty parentheses.)

RESTORE

The RESTORE command is used in connection with READ and DATA statements. As we know, Basic reads DATA statements in the order in which they appear in the program, and ordinarily it reads each DATA statement once and then discards it. But sometimes a program might require that the DATA statements be read more than once - for instance, the user might be permitted to repeat the program by answering a prompt, in which case the DATA statements must be read again. The simple command

RESTORE

(on a line by itself) instructs Basic to begin reading the DATA statements again from the beginning. It might appear in a sequence like the following:

INPUT "Do you want to repeat the program"; ans$
IF ans$ = "y" THEN
RESTORE
GOTO Begin
END IF
PRINT "OK - Bye"

If you want to begin reading data following a certain label in the program, then you may modify the RESTORE statement to

RESTORE Label

where in the place of "Label" you insert the desired label.

SELECT CASE

A SELECT CASE procedure can be used in place of an IF - THEN - ELSE procedure, and is frequently more convenient. The general format is

SELECT CASE variable or expression
CASE IS condition 1
instructions
CASE IS condition 2
instructions
·····
and so on
·····
CASE IS condition N
instructions
END SELECT

Example :

INPUT "What is your age"; age
SELECT CASE age
CASE IS < 18
PRINT "You can neither vote nor retire"
CASE IS < 65
PRINT "You can vote but you cannot retire"
CASE IS >= 65
PRINT "You can vote and you can retire"
END SELECT

In the example, "CASE" takes the value of "age" and the conditions are checked. Basic executes the instructions following the first condition checking true, and no others. Thus, although a person of age 5 would satisfy both conditions CASE < 18 and CASE < 65, only the instructions under CASE < 18 are carried out since this condition is listed first.

If it happens that none of the conditions in a SELECT CASE procedure check out as true, then no instructions are carried out and Basic proceeds to the next statement in the program. Sometimes a last case, labeled CASE ELSE, is placed at the end of a SELECT CASE procedure in order to take care of all miscellaneous cases that might occur but were not listed. Here is an example:

Prompt:
INPUT "Do you want to repeat the program (enter y or n)"; ans$
SELECT CASE ans$
Case = "n"
PRINT "OK - Bye"
END
CASE = "y"
GOTO Begin
CASE ELSE
PRINT "You did not follow the instructions"
GOTO Prompt
END SELECT

Note that if the user errors and enters any letter besides "y" or "n", then the miscellaneous "ELSE" case takes over and returns the program back to the prompt.

You may also specify a range of values as a condition in a SELECT CASE procedure, as the following example illustrates:

INPUT "What is your age"; age
SELECT CASE age
CASE 0 TO 12
PRINT "You are a child"
CASE 13 TO 19
PRINT "You are a teenager"
CASE 20 TO 39
PRINT "You are a young adult"
CASE 40 TO 59
PRINT "You are middle-aged"
CASE ELSE
PRINT "You are a senior citizen"
END SELECT

If age < 13 then the first case instructions are followed, while if 12 < age < 20 the second case instructions are carried out, etc. The "ELSE" case includes all ages 60 and above, as these are the ages not included in any of the preceding ranges.

WHILE ... WEND

This loop construction works exactly like the DO WHILE … LOOP. Its form is

WHILE condition
instructions
WEND

As long as the condition is satisfied, the loop continues and the instructions are carried out. The WEND statement marks the bottom of the loop.

The construction below adds the integers from 1 to 10 and prints the result:

N = 1: sum = 0
WHILE N <= 10
sum = sum + N
N = N + 1
WEND
PRINT "The sum is "; sum

The WHILE … WEND loop is a holdover from earlier versions of Basic; it is retained in later versions only because old-time programmers are already familiar with it. However, the loop is unnecessary as it has been superseded by the more versatile four versions of the DO … LOOP. You are probably better off not using it.

EXIT (Four Uses)

The EXIT command can be used not only to jump out of loops, but also to jump from subprograms and from function definitions. Here are four versions of EXIT, with explanations:

Exit Statement Purpose
EXIT FOR Exits FOR … NEXT LOOP
EXIT DO Exits DO … LOOP
EXIT SUB Exits Subprogram
EXIT DEF Exits Function Definition

An EXIT from a subprogram or a function definition produces a jump to the next statement in the main program following the calling of the subprogram or definition.

Aligning Print Data

Here is a trick you can use to align into columns large quantities of data being printed in a loop. Let us suppose you want to print the squares of all the integers from 1 to 100. You can do so with the following loop:

FOR K = 1 TO 100
PRINT K ^ 2
NEXT K

The problem with this simple program is that the data will not be aligned nicely in columns. Moreover, if the PRINT statement is changed to PRINT# so that the data is printed to a file instead of the screen, then output will run off the right side of the screen when the file is viewed in Basic.

To align the data into columns we insert a print counter P, keeping track of the number of print operations. We include also in the loop a TAB statement informing Basic in which column to begin the next print, depending on the value of P. One possible way of doing this is with the sequence

P = 0
FOR K = 1 TO 100
PRINT TAB(1 + 10 * (P MOD 8)); K ^ 2
P = P + 1
NEXT K

The first time through the loop, P = 0 and P MOD 8 = 0, so that data is printed in column 1. The second time through the loop, P = 1 and P MOD 8 = 1, so data is printed in column 11. The third time through the loop, P = 2 and P MOD 8 = 2, and data is printed in column 21. Each time through the loop the column for printing moves 10 spaces to the right, all the way up to the eighth time through the loop when P = 7. But the ninth time through the loop, when P = 8, then P MOD 8 = 0 again, so printing returns back to column 1 and thus to the next line.

The upshot of all this is that we get 8 vertical columns of data, and the leftmost edges of these columns are 10 Basic columns apart. (Since Basic uses only 80 columns, we must be careful not to specify a printing beyond that number - doing so would mess things up.)

More generally, if you want to print K vertical columns of data, with leftmost edges M Basic columns apart, you would change the TAB statement to

TAB(1 + M * (P MOD K))

But you should choose M and K so that MK is no larger than about 80, as otherwise you risk running off the right side of the screen.