TI 89/92 BASIC Programming manual

Chapter One: The Basics

Chapter Two: Program Design

Chapter Three: Writing a Function

Chapter Four: Inputting Variables

Chapter Five: Loops and Blocks

Chapter Six: Output

Chapter Seven: Advanced Stuff

Appendix A - FAQ

1
 Introduction

OK. You have a TI-89 or a TI-92, you’re in a math or science class, and you want to program it. Where do

you start? In fact, for some people, the question is, “What is a program, anyway?” You may get along by

looking at your manual to see programming examples, but you can’t make your program work. Now what?

Read through this document. You may actually learn something.

Chapter One: The Basics

A program is, in its most basic form, a set of instructions that makes the calculator do what you want it to

do. A program can be a simple as adding two numbers, or as complex as calculating and drawing fractals.

There are three types of programs in the TI world: a program (duh!), a function, and a macro. (Because a

macro is a simple form of a program but is dreadfully tedious, I won’t go into detail. They have less

capabilities, anyway.) A function is a simpler form of the remaining two, since it doesn’t allow the writer to

store any variables. All variables must be inputted before the function is run (I’ll explain in Chapter Three).

A program, on the other hand, is much more advanced, but don’t let that scare you. A program allows the

writer to do just about everything that can be done on the HOME screen, except turn the power on and off.

Chapter Two: Program Design

Now you ask, “So, now that I know the difference between a function and a program, how do I decide

which is better?” It all depends on what you want to do. To calculate sales tax, you don’t need a program; a

function will do nicely. But, if you want to play Blackjack with your calculator, a function simply won’t

do.

The main question to ask yourself is, “Am I just performing calculations on a set of numbers, or does the

routine (a generic name for either a program or a function) need to ‘think?’” If you answered “yes” to the

first question, you probably want a function. If you answered “yes” to the second question, you need a

program.

All routines follow a basic pattern. For a start, create a new program by pressing [APPS] on the keypad.

Find the item labeled “Program Editor.” Using the arrow keys, scroll down to that item and press enter.

(For power users, hit the corresponding number. It should be number seven.) When you do, it will come up

2
with a sub-menu. You have three choices: Current (which opens the last edited program or creates a new

one if the program is not found), Open (which opens a stored program), and New (which creates a new

routine). Press [3]. Now, you are shown a dialog box. The first item, Type, should have a drop-down box

(flashing) that says Program. Press the right arrow key. Now, you have a choice to either create a function

or a program. See the picture below:

We’ll leave that alone for now, so press [ESC]. Hit the down arrow. Now the Folder drop-down menu is
showing. Usually, you won’t have to change that. Press the down arrow again. Now, you can enter the
name of the program. It can be any name not being currently used, such as “solve” or “Disp,” it can’t start
with a number (but it can have numbers in it), and it must be eight characters or less. Call your program
“abc.” (By the way, capitalization doesn’t matter – it all turns into lower case.) The screen should look like
this:

For a program, scroll directly to the third line. Functions start elsewhere, so read on.

Chapter Three: Writing a Function

Go back to the home screen (press [HOME]) and delete the program you just made. If you don’t know

how, refer to your guidebook.) Create a function (same thing you just did to create the program, except

choose “Function” in the New dialog box), and call it “abc.”

Your screen should look like this:

3
The cursor is blinking between the parentheses. Here is where you need to enter the names of the input

variables.

Suppose the program is designed to square a number and then add that number with three times that

number. First, you need a variable name. We’ll use “num.” Put the alpha-lock on (press the purple

[ALPHA] key twice) and type “num” in the parentheses.

Scroll down until your cursor is on the blank line. Now, push the calculator aside.
Think mathematically of what needs to be done to the variable num. First, we squared it. (It may be

a good idea to write this out so you can see what you need to do.) So, the equation we would use is

num 2 , or, as TI calculators go, num^2. After we square it, we need to add three times the original

number, or 3*num. (Notice this is all on the same program line; for more than one variable, as we’ll

do later, it may get more complex.) When we combine everything, the expression is num + 3num , or
2

num^2 + 3*num. Now, let’s do a few trials. Take the number two. Two squared is four. Two times

three is six. Four plus six equals 10. Now try three. Three squared is nine. Three times three equals

nine. Nine plus nine is eighteen. What about four? Four squared is sixteen. Four times three is

twelve. Twelve plus sixteen equals twenty-eight.

Now that we have the gist of what is going on in the problem, pick the calculator back up (if it powered
down automatically, press the [ON] button – it should come back to where you left off). First, we squared
num. Type “num^2” without the quotation marks. Now, we need to add three multiplied by num. Type
“+3*num.” The screen should look like this:

Now, hit [HOME]. Type “abc(“ without the quotes. Freebie: when you test your program, choose variables
that you’ve already performed the calculations. When you get the calculator’s answer, compare it with what
you got to make sure it’s right. Since we’ve already done two, three, and four, choose one of those
numbers. I’m going to use two. So, type a two after the first parenthesis and close the parentheses off.
(Semi-freebie: parentheses is the plural form of parenthesis, just so you don’t get confused.) Type
[ENTER] to run the program:

4
As you can see, ten is the correct answer. Congratulations! You’ve just made and run your first simple
function! Now, we’ll try a two-variable function.
Suppose you want to calculate x2+3x on one number and add it to y2-3y on another number. Let’s stick with
x=2, and let y=4. We already know that x2+3x=10. By simple algebra, y2-3y=4. 10+4=20. Now, try five.
y2-3y=10 for y=5. 10+10=20. Want to try eight? 82-3*8=40. 40+10=50. Now, try to integrate this into the
function you just wrote.
Open the function abc. ([APPS], [7], [2], [RIGHT ARROW], [DOWN ARROW], [ENTER], [DOWN
ARROW], [DOWN ARROW]). Press enter when you’ve located abc. In the variables line, add num2 to the
list. Scroll back down to the line that says num^2+3*num. Push [2nd] and [LEFT ARROW] to go to the
beginning of the line and push [ ( ]. This will open the parentheses. Push [2nd] then [RIGHT ARROW] to go
to the end of the line. Press [ ) ] to close the parentheses. Now, enter the second expression in terms of
num2. Be sure to put the plus sign in and add the parentheses!

If you have a TI-89, the lines should look like this:

Notice the function “wrapped” around on lines three and four. Don’t worry; it’ll still work. Go back to the
home screen. Type “abc(2,8)” and press [ENTER]. This tells the function to calculate
(22+3*2) + (82-3*8), which we already decided was fifty. The screen should read

*AN IMPORTANT NOTE ABOUT FUNCTIONS: the function will return the value to the home screen.
When you get down to the nitty-gritty of it (skip this if you don’t want to confuse yourself), by not storing
the value of the expression into another variable, it’s being stored to the function itself. For those of you
who know MS Basic, this is the same function:
10 SUB abc(num, num2)
20 abc = (num ^ 2 + 3 * num) + (num2 ^ 2 – 3 * num2)
30 END SUB
40
50 PRINT abc(num, num2)

The subroutine called abc is created as an integer by default. However, the value for abc is empty when the

program first runs. Line 20 actually assigns a value to abc (50). The program calculates this and displays it

on the first available line.

This is similar to the way a function runs on the TI calculator. However, the value is not explicitly

5
assigned; it is an assumed assignment. You can prove this by entering “15+abc(2,8)” and pressing

[ENTER].

If the function simply displayed the value, the expression you just entered would return “abc(2,8)+15”. But,

it should look like this:

And that’s not all. Try this: “abc(abc(2,3),4)”. Now, you’re nesting the two functions. What this actually
works out to be is (abc(2,3)2 + 3*abc(2,3))+(42 – 3*4). This may seem incredibly nasty, especially when you
try to write the expression with all the numbers. But, the reason I did this was to show how a function can
be used as a variable in calculations, which makes it such a versatile tool.

Chapter Four: Inputting Variables

We’ve just considered a function, where the inputs are taken care of on the home screen. But say you’re

creating a program. How do you put variables into the program?

One way is doing what you just did in a function. But, that method can be tedious and confusing, especially

when the program has more than two or three variables.

The easiest way to input a variable is by using the Input command. This is the syntax (the way the

command needs to be written in order for it to work):

Input [input string; what do you want to ask?], variable name

The bracketed section is optional. If the string is not present, the command will show a question mark. For

example, if you type

Input “What is 1+1?”,answer,

the program screen will show this:

6
 Program entry This is what is shown when the
program runs.

Please note that the Input command is used only to input numbers (including lists, vectors, and matrices).

Which brings me to the next topic: what do you do to input strings? For that, the command needed is

InputStr. This command has the same syntax as Input, but it takes everything entered, including non-

mathematical characters (those that can be accessed from the CHAR menu) and treats it as if it was entered

in quotation marks. Here is an example:

Program entry This is what is shown when the

program runs

There is an interesting relation between the two Input commands. In the Input command, you can still enter

a string, but it must be entered within quotation marks. However, there is no way to enter a number with the

InputStr command . . . from the program input screen. Here’s a tip for power users. It really doesn’t matter

which you use because there’s ways of getting around both of them. You can get a string in from the

numerical input command first off. If you want to enter an expression (like 14.23+556.4, something that I

wouldn’t want to add in my head), do so. The variable ‘answer’ will be stored as “14.23+556.4”. Now, you

can use the “expr(“ command to change the 14.23+556.4 into 570.63. Semi-freebie: you can even enter

functions like “x+3” in and change it into an expression. But, you can’t enter the command

“expr(answer)->y1(x)”.

You can, however, enter this:

“expr(answer)->f

3->x”

Now, feel free to use the integer “f” in calculations.

7
A similar command to the Input command is the Prompt command. The syntax is as follows:

Prompt var1,…

This is somewhat simpler, but it’s limited in its usage. It can, however, be set to take a series of inputs with

just one command. Example: say you want the user of the program to enter five numbers at random. You

would use this command:

Prompt num1,num2,num3,num4,num5

This would display a question mark on the program input screen, and the user would enter the number and

press [ENTER]. Then, it would immediately flash another question mark up, and the user would enter the

second number, and so on until all five numbers have been inputted.

So far, we’ve just covered the easy ways to input. If you want to stop with that, feel free to go to the next

chapter on Loops. But, if you’re interested in taking the program a step above mediocre, read on.

There are three more kinds of inputs that can be used. One of them is by using dialog boxes. Dialog boxes

are the kinds of things you see when you try to do something illegal. See the illustration below:

That, in a very simple form, is a dialog box. A dialog box consists of a title (“Error” in the example; an
optional part), one or two buttons at the bottom (usually “Enter=Accept” and “Esc=Cancel”), and any
goodies you want to put in, such as straight text (“Too few arguments” in the example), input boxes, and
drop-down menus.
The setup of a dialog box is a little more complex that just one command. To start, create a program. Go to
the I/O menu and select Dialog. (For future reference, this is all on the TI-89 menu screens. If you’re
working on a TI-92 or a TI-92 plus, the menu’s may be a little different, but the principle is the same. If
you can’t find it the way I described it, just use the Catalog feature and select the commands manually, or
consult your calculator’s guidebook.) When you select “Dialog”, a submenu comes up, which gives you all
the options you need for your dialog box (or custom toolbar, but I won’t get into that). Select option
number five, which should read “Dialog…EndDlog”. This will paste the command into the editor, leaving
a blank line between the two lines. See below:

Now, feel free to experiment around with the different commands. Here’s an overview of the options:
Purpose Syntax
Text Allows you to put text in the Text string
dialog box

8
 Request Allows entry of ONLY strings; Request prompt, var
input can be changed later.
DropDown Presents the user with a DropDown prompt, [string1,…],
numbered list of choices var
Title Allows you to specify the title on Title string
the dialog box

NOTE: The Request command can be used by itself, free from any dialog block. The syntax is still the

same.

This is an example of all the elements in action (the indenting in the program is optional – I think it clears

things up a little, especially when we get to the next chapter. Please note that the program is simply an

excerpt of the entire block.

This is the program code, and this is the actual dialog box.

There is another command in the dialog menu that I didn’t cover, and that is the Popup command. This is

an illegal command to use in the dialog box framework. So why is it in there? Because it, like the Request

command, creates a simple “dialog box” all on its own. However, this is a different kind of dialog box.

Press the [APPS] key. See the box that pops up? That’s the same kind of box that the Popup command

creates.

Now, you’ll notice that the first item on my calculator’s popup is the FlashApps button. This is because I

have installed OS 2.0x on my calculator. That doesn’t make any difference in the keystrokes that I’ve given

in this manual. Visit http://www.ti.com for flash updates.

The PopUp command has this syntax:

PopUp itemlist, var

9
The itemlist variable contains a list of the items, stored as string elements in a list, that will appear on the

popup. Var is the variable that the response is stored to. Here’s an example:

This is the program code, and this is the popup box.

That about does it for dialog boxes. If there are other question on syntax, or you want better examples, try

the guidebook that came with the calculator.

There is yet still one more method of inputting a user’s response, but it’s not a variable input. It is called

getKey(), and you won’t find many programmers that use it anymore (except for games). GetKey() is a

function that, when used in a loop (which I’ll talk about in the next chapter), returns the ID number of a

pressed key. (For example, the ID number of the [ENTER] key is 13.) This is great for games, like I

mentioned, because the programmer can control the flow of the game based on which arrow the user

presses, for example. However, for useful academic programs, you won’t need this. But, bear this in mind,

because I will come back to it.

Chapter Five: Loops and Blocks

One quick note: this chapter is probably one of the most in-depth chapters here. You may need to read

through a few times to get yourself comfortable with using these features.

A loop will be, usually, the biggest part of any well-written program. A loop is a block of instructions that

repeats itself a certain number of time, until a certain condition is true, or indefinitely (the user must stop it

somehow).

Let’s start with the most common loop: the If…EndIf loop. (An If…EndIf loop is called a conditional loop,

even though it’s not really a loop at all – it’s a block set.) The If…EndIf structure looks at a variable (or a

set of variables) to see of a condition is true. Here’s the syntax:

If condition Then
command(s) when true
Else[If condition Then]
command(s) when false or
command(s) when ElseIf condition true

10
EndIf

There are also nifty little things called Boolean operators. These include and, or, not, and xor. Mostly,

you’ll use these in the If…EndIf statements to define two different conditions (If 1+2=3 or 4+5=9 Then…)

The easiest way to explain the If…EndIf loop is by doing an example. We’ll use the Input and Disp

commands. Enter this into the program editor:

Please note that the blank lines are there only to separate the two sections. You don’t need the two blank
lines in your program. When you run the program, you’ll be asked to enter three numbers. When you first
run the program, enter the third number as the sum of the first two. When you run the program again, don’t
let the third number be the sum of the other two. Can you follow the If…EndIf statement and predict what
will happen?
This is how the If…EndIf block works: The condition of the If statement checks to see whether a (n1) and
b (n2) add up to c (n3). If so, the program proceeds to the first line following the Then and then executes all
the commands up until the next conditional statement (Else), where it goes to the next line following the
EndIf. However, if a and b don’t add up to c, it skips down until it sees the Else line, and then executes all
the code until it’s told to stop (EndIf). Simple right? Let me re-write the statements into English: “If n1 and
n2 add up to n3, then display “Numbers work” on the program I/O screen. But, if n1 and n2 don’t add up to
n3, then display “Numbers don’t work” on the program I/O screen.” Make more sense?
Another command for the If…EndIf block is the ElseIf statement. Go back and enter this line after the
“Disp ‘Numbers work’” line:
ElseIf n1+n2>n3 Then
Disp “Numbers really don’t work”

Here’s that middle line in English: “If n1 and n2 don’t add up to n3, AND n1 and n2 add up to something

more than n3, then display “Numbers REALLY don’t work”. If n1 and n2 are less than n3 [the Else line],

then display “Numbers don’t work”.”

Once you get the hang of it, If…EndIf blocks actually aren’t that hard. If you nest several If…EndIf blocks,

though, indent them. Nothing confuses me more than having three EndIf statements and not knowing which

loop I’m in. And, as we move on, remember that indenting is usually a good idea in any loop, regardless of

its function.

11
The next type of loop is the For…EndFor loop. Now, don’t ask me where “For” came from originally,

because I have no clue. (That’s probably something like the story of how program glitches became known

as bugs. In days of yore, before 386 computers, the military had four-banger calculators the size of small

houses. They had to program these computers using punch cards – cards with holes in them that

represented one line of code. One day, a particular program wouldn’t work, and no one knew why. It was

only until after they looked at the punch card carefully that they noticed a fly had gotten killed and stuck

inside one of the little holes. Hence the phrase “a program bug.”) All I know is that the earliest version of

MS Basic, circa 1982, called their loop a For…Next loop, and the expression kinda stuck. Of course, TI

couldn’t break with the tradition of stopping their loops with End-something, so they used EndFor instead

of Next.

For…EndFor loops are used to increment values. The makes it an invaluable tool when running a counter.

The syntax is:

For var, start value, end value[, step size]

command(s) to loop through
EndFor

Let’s walk through this loop. The first statement initializes the loop and sets it to run from start value to

end value. Var is increased by the step size value (which, if left blank, defaults to 1) every time the loop

recycles itself (goes back to the beginning of the loop). BTW, remember when I said something about the

Basic For…Next loop? Next actually makes a more appropriate statement. The loop doesn’t end every time

it reaches that command; it goes to the next variable. Why TI changed it, I don’t know, other than the

reason I gave above.

Now, let’s try an example. Suppose I have a list of five items (all numbers), and I want to input them, then

store them into a list. If you’ve paid attention in previous chapters, you should know to use five separate

Input commands to get five separate variables and store them one by one in a list. Of course, if you were

really paying attention, you should have realized by know that you could use the Prompt command rather

than repeat yourself five separate times. Here’s an easier way:

12
Let’s step through this. The newList command was pulled off the catalog. It takes the number in

parentheses and creates a list with that number of elements. The For statement was already discussed. You

should know what the Input command does. Now, what’s that next line for? That takes the variable L and

stores it into the variable list, element number i. On the first pass through the program, the user inputs the

first number. (Keep in mind that at this point, i is one.) Then, it stores it into what is, for all intents and

purposes, is list[1]. On the second pass, the user inputs the second number. The variable i is now two. L is

stored into essentially list[2], and so on and so forth until i runs out of numbers. If you were to run the

program (go ahead – you know you want to!), you would find that the variable list reads as the numbers

you put through the Input command. (Now – some people who were really paying attention would ask

“Why can’t you use the Input command to input the list right off?” Congrats – you get a gold star for

attentiveness, but the example was just to show how the For…EndFor loop is used. I’m sure all you gold-

star people out there can think of some other uses for For…EndFor loops.)

The nice thing about the For loop is that a.) it’s cycled automatically, and b.) var can be used in

calculations like any other variable. But, suppose, for some reason, you want to skip lines of code and jump

right to the next number in the loop? You may have 15 to 20 lines of code in the loop, but, if a certain

condition is met, you only want four of those lines to go through before the loop repeats. How do you tell

the loop to skip around? Answer: use the Cycle command. Usually used in a For loop, the Cycle command

will, regardless of the commands below it, jump back to the start of the For loop, after incrementing var.

The syntax is simple: Cycle.

Another type of loop is the While…EndWhile loop. This loop is really just an extension of the If…EndIf

block. Now, for a quick moment, go back in time. Remember when I used the getKey() function? Well,

getKey() works best in a While…EndWhile or Loop…EndLoop loop. Here’s how a While loop works. The

syntax is simple:

While condition
command(s) while condition is true

13
EndWhile
command(s) while condition is false

If the listed condition is true, then the block will continue to loop through instructions, UNTIL THE

CONDITION IS NO LONGER TRUE. At that point, the loop will exit itself and continue the program.

Here’s an example using both getKey() and While…EndWhile:

*If no key is pressed, getKey() returns 0, so the condition is true if the user
keeps his grubby little mitts off the keypad.

Store this program to see how it works. (BTW, this is the most basic form that getKey() is used in.)

The Loop…EndLoop is identical to the Do…Loop in Basic. It is the most basic, rudimentary loop of them

all, except it is rarely used. (With the much more powerful and compact While…EndWhile and For…

EndFor [they can be duplicated by using an If…EndIf inside a Loop…EndLoop], who needs anything

else?) By and large, the only reason Loop was put in was so the changeovers from the 85, 86, 82, and 73

could manage. You probably won’t have much use for a Loop statement, but it’s in there anyway. If you

decide to use it, the syntax is:

Loop
command(s)
EndLoop

Pretty simple, huh? BTW, the only way to get out of here is to use a Goto statement or the Exit statement.

(The Exit statement, if you’re wondering, will kick you out of just about everything except the program

itself.)

Another type of “loop” is the Try…EndTry block. You’ll use this mostly for error-handling. It is very

similar to the If…EndIf. This is the syntax:

Try
operation(s) to try
Else
what happens if any one operation fails
EndTry

The only time I really use this is after a dialog box. The main reason I put it there is to make sure that

something was entered correctly in every Request box. Here’s an example:

14
Punch this in your program editor, and run the program. See what happens when you don’t enter something

in the n2 request form. (A note: if you missed if a few pages back, the Request command inputs only

strings; hence the necessity for the two “expr(” commands.)

The last block statement isn’t really a programming matter, but I’d figured I’d put it in anyway. You can

consult your guidebook if you want to pursue using it. I’m talking about the Custom…EndCustm block.

This allows you to set the custom menu bar, accessible through the [2nd][CUSTOM] on the keyboard.

That’s it for all the blocks and loops. Now we move to the final stage of the program:

Chapter Six: Output

All right. So you’ve created the perfect program. Everything works beautifully, and all the calculations are

done to perfection. Unfortunately, all your perfect calculations do the end-user absolutely no good at all if

they can’t access the information somehow. So, how do you get information out from the program and back

to the user?

The easiest, but most cumbersome, mode of output is by using the Disp command. Disp, of course, is short

for Display. This is the most simple command. It takes whatever is behind the command, string or

otherwise, and displays it on the program I/O screen. The syntax is relatively straightforward:

Disp [var 1, var 2, etc.]

Disp without anything behind it simply returns a blank line. If you want to display more than one variable

(it will go from line to line; in other words, it won’t create a continuous line), simply separate them with

commas.

The Output command is similar, except with this command, you can actually specify the place on the

output screen that the text is to be written to. This is the syntax:

Output row, col, var

The row and col specify the x- and y-coordinates at which the text is to be displayed.

15
 This: displays this:

This: displays this:

The Output command is a little finicky in that you have to know the pixel coordinates for the thing you’re
outputting; however, if you master the Output command, you can make your program output look a little
more neater, rather than having massive gaps between the Disp lines that could cause the user to lose
information.
Now, there are several other commands used for output. Remember Request, the Dialog command that
could stand alone? Well, Text can also stand alone. The syntax is the same as listed a few pages earlier.
But, if you really want to look good, try creating a complete dialog box. (There is no difference between an
input dialog box and an output dialog box except for the stuffing. Input dialog boxes have mostly Request
boxes; output dialog boxes have mostly Text statements.)

Chapter Seven: Advanced Stuff

Well! You’ve finally made it through the easy stuff. Now, my knowledge as an advanced programmer is

going to come out.

First off, let’s discuss imbedded routines.

The included program, Vectors-89 v2.1, has an example of imbedded routines. Two examples, in fact. An

imbedded routine is a routine that can be called from inside the same program. Usually, imbedded routines

take the form of a function, but they can be programs. The whole reason behind imbedded routines is to

save yourself from repeating frequently used lines of code. For example, in Vectors-89, I had to frequently

test bearings (0 or 360 degrees was straight North, 90 degrees was East, 180 degrees was South, and 270

degrees was West) and adjust them by .01 of they fell directly on any of the above listed numbers. The

code to do so was six or seven lines long, so I imbedded a function routine at the beginning of the code (by

the way, that’s a requirement for imbedded code – it’s got to be immediately after the Local statement and

immediately before any other code) that would take the bearing entered and adjust it if necessary. Then,

when I needed to adjust the bearing, I just entered the routine name as if I was entering a built-in function

like Solve(), using the bearing as the input variable. The function would return the adjusted bearing, and I

would store that back into the user’s bearing. See the program for what I did.

16
 * The last line of this program was cut off; it’s “EndFunc”.
You’ll notice that, except for the “Define fixb(b)=” statement, the routine follows the exact same syntax as
a normal function would. So, whenever I wanted to adjust a bearing (b1 or b2 by name), I would enter
“fixb(b1)→b1”. The program would know to find the locally defined function fixb(b) and would run it on
the variable b1. At the end of the function, fixb(b) now had stored in it the adjusted bearing, if any (notice
the combination of an ElseIf and Else statement.), that I could store back into b1. This also has a perfect
lead-in into my next point: code compression.
When I first wrote the original draft of Vectors-89, it was over 150 lines. That’s a fairly big program, no
matter how you cut it. The bigger the program is, the longer it takes to compile, and the longer it takes to
run. So, I was faced with the task of optimizing my code. Optimization is the term programmers use for the
process of cutting down the size of the program by combining some things, creating imbedded subroutines,
and taking out unnecessary parts. By the time I was finished with it, Vectors-89 v1.1 was almost half the
size.
This step is crucial for the internet developer. Bigger files take longer to download, and, as mentioned
above, they can run slower once the user has finally downloaded the program and gotten it on his
calculator. By cutting down the size of the program, the developer insures a happier consumer, provided
that the program was well-written. It doesn’t matter how small the code is if the program doesn’t work!
Another thing that advanced programmers do is create Local statements. This statement instructs the
program to delete the listed variables before the program ends. You may have noticed that you folder is
filled up with several variables from the example programs you should have created. If there was a local
statement in each, the variable would be deleted, and you wouldn’t see it after the program ends. Here’s
where you have to be careful, though, because there are some functions, like the “when(” function, that
can’t take a local variable. However, there’s a way around that. If you find that the function can’t take local
variables, don’t make them local. Put a line at the end of the program that says “DelVar…” and tack on the
variables you want to delete. When you get down to it, a Local statement is just a DelVar statement in
advance of any of the variables being created.
Finally, TI calculator programmers can also call other programs. This is similar to using imbedded
functions, but instead you’re calling outside programs, not inside ones. Here’s the catch – when you’re
writing an external program (program, not function), you have to place a Return statement right before the
EndPrgm statement. If you didn’t, the main program would simply stop when the external program
stopped. And then where would you be?

17
 Appendix A - FAQ

Well, it’s been quite a while since I’ve opened this file. I’d first off like to thank all the people who’ve

downloaded this file. I’ve gotten nothing but positive feedback (with the possible exception of people

complaining about the file size). Well, it’s because of you that this manual has been so successful, so I

thought I’d include a section to list some questions that have been emailed me recently.

Q. Why on earth is the file so huge???

A. Because Microsoft is stupid. Seriously, it’s probably because of the imbedded graphics. Thanks go

to Joe B. for essentially forcing me to convert this into an RTF file so he could read it in Word 97.

Bingo! File size went down from 8mb to 1mb. Happy?

Q. I keep getting this error message (“A test did not resolve to true or false”) and the calculator

instruction manual could be printed in Esperanto for all I understand of it!!!

A. Calm down. Number one, since Esperanto hasn’t been around for more than two years, it’s

unlikely that the manual is in that language (and yes, it’s a language; visit

http://www.esperanto.net for more info). Number two, all it means is you have to fix the same

things in just a few lines of code. Consider this example:

:a()
:Prgm
:1->x
:If x = 2 Then
: Disp “2”
:EndIf
:EndPrgm

Do you see the problem? TI-BASIC has to be told exactly what to do. It can’t figure out which

way is up because it’s only set up to do something if x is equal to 2. It gags when it realizes that

it’s left hanging. What do I do if x isn’t equal to 2? I dunno!

Here’s the fix. It’s usually a good policy to put an “Else” statement in there to tell it what to do if

all else fails. That, or if you’re certain that x will be a within a certain range of numbers, you can

add ElseIf statements in the block to tell it specifically what to do.

18
Q. I think you were just speaking Esperanto there.

A. Nope. Go back and read Chapter Five again.

Q. I tried inputting numbers in my dialog box. But, when I try to do math on those numbers, I get

really weird results. Any ideas?

A. Thanks go to Robert F. for pointing this out. TI-BASIC is too stupid to differentiate between

different variable types when you enter them into the dialog box. In actuality, it would probably

more of a hassle if it could. Here’s what’s going on: anything you enter into that little Request box

gets stored in a string. Doesn’t matter if it’s a number, matrix, or your favorite recipe for chicken

soup – it all is stored as a string. I know that math courses can get a little deep, but I don’t ever

recall having to divide “Hello World!” by “Testing…1, 2, 3” before. But, if you don’t process the

inputs, that’s what the calculator is trying to do, sometimes with interesting results. Let’s go back

to third grade math. Three divided by three is…one. Ten divided by ten is…one. One billion

divided by one billion is…one. So, as far as TI is concerned, “Hello World” divided by “Hello

World” is…one. This presents minor problems. Here’s how to get around it. After you finish your

dialog box, it should be standard practice to throw in a Try…Else…EndTry loop to make sure the

variables were all filled in. For your commands in the Try section, you’re going to want to put in a

few expr(variable) -> variable statements, provided you wanted numbers, matrices, or lists. If you

wanted strings, then don’t use the expr( command. (This takes whatever string is in there and

converts it into a number. For example, expr(“2”) returns the integer 2. If the variable ‘test’ has

the list {1,2,3} stored in it and you type expr(test), you will get the list {1,2,3}. Make sense?) By

using this function, you can change “5” into 5 and do stuff to it.

Q. Are you making a list of all the commands and explaining them?

A. Hah! I have a life, too. No, I’m not planning to document every single command, function, and

expression. That would take a little too much time. College students tend not to have hours upon

hours of free time to do something so tedious. Email me with specific questions, but don’t hold

your breath waiting for a complete list. Sorry.

19
Q. Is there a way of seeing if the [ENTER] or [CANCEL] keys are pressed in a dialog box?

A. I’m glad you asked. Yes, there is. TI hides some expressions in the calculator, such as the

variables ‘ok’ and ‘cancel’. Three guesses as to what these variables are, and the first two don’t

count. Depending on whether [ENTER] (ok) or [CANCEL] (cancel) is pressed, the appropriate

variable will be 1 or 0. Please note that this is only meant for custom dialog boxes. Since there

isn’t a way that I know of to call a system dialog box, such as the Open or Var-Link boxes, these

can only apply to custom user-made boxes.

Q. When I make a dialog box, the alpha lock gets turned on as soon as the box opens. Is there a way

around that?

A. Unfortunately, no. At least, it’s not the easiest thing in the world to do. I’m going to do something

I rarely do – defend TI. If you read the first question, you came across the suggestion that I had

regarding the expr( command. I did this with this question in mind. Something that TI did

somewhere around AMS 2.04 was put this little auto alpha-lock feature in, most likely to appease

the people that don’t know to push the alpha key when they create a folder. As much as it is an

inconvenience, it’s probably better in the long run. See, the calculator’s memory doesn’t have the

free space to program it to differentiate between an integer entered in a Request box and a string in

the same box. So, because the (supposed) majority of people enter strings into this box, TI put this

feature in. Now, for those of us that think it’s the worst idea TI has come out with yet, there is an

alternative. I don’t have the URL here, but I’m sure you can find the program. Someone wrote a

TSR (Terminate and Stay Resident) program to turn off the alpha lock at any dialog box. (A TSR,

for those of you that are wondering, is a program that, once it’s run, moves itself from active

memory. It’s not running where it taking user memory, but it runs whenever a certain event

happens. For more info, look into ASM programming. That’s too complex to write about here.)

Now, there is a disadvantage. Whenever you open a dialog box (the New command in the Var-

Link screen, for example), the only thing you can enter is text for the new folder name. The new

built-in feature allows you to start typing automatically. Still, I personally find it a little annoying.

20
 So, there’s an alternative. There is a command that allows you to execute a snippet of assembly

code in a BASIC program. The exec( command allows you to put in a hex code that runs assembly

lines. If you don’t understand a word of what I just said, don’t worry. All you need to know is that

you can enter a line that will turn off the alpha lock at the start of the program. That way, you can

choose whether or not to disable the lock when you start the program. You can also play around

and get it to turn the lock on when you need it. However, please don’t email me and ask what the

hex code is. I DON’T KNOW IT! Here I give you permission to hold your breath: I may have a

way to get it, but you may be better off getting the program I mentioned above instead.

Q. Can I do conversions between units in my program?

A. Well…yes and no. To keep it simple, no. There’s no practical way of converting 2 meters into 200

centimeters within a program. Try it and see. Type “2_m►_cm→x” You’ll get a syntax error.

Now, if you really absolutely want to do it, I would suggest this snippet of a program.

When all is said and done, the program creates a dialog box with the result (“200_cm”) stored as a

string. The program takes the string stored in m (in this case, “200”), tacks on the remaining part

so it can be evaluated, and stores the entire answer string in t. Then, the next line looks through

that string and finds the “*”, indicating the unit converted to. It then strips off the last part of the

string, leaving the “200”. I added the “_cm” to the end, allowing me to use the expr function to do

calculations to the answer. If you’re still confused, send me an email (address is at the end of the

document) and I’ll explain in greater detail.

21
Q. Can I store variables in the function?

A. Contrary to what I said before, you can. The reason I didn’t get into that was because it was a little

complicated. Generally, storing variables in a function is a bad idea, but if you must, then here’s

how: when you write your function, map out any variables that are to be stored. Once you have the

list of things to store, the first line in your function needs to be a Local statement. Put any and all

stored variables after the Local statement, separated by commas. The function will now allow you

to store variables. But why on earth would I need to do this, you ask. Well, I’ve come across times

when I needed to store something as a temporary variable but really didn’t feel like changing the

function to a program. So, before I found this little trick, I had to rewrite the function to avoid the

temp file. Oh well.

Q. Do you have a website?

A. Actually, yes, I do – http://usa.internations.net/cyber/CalcTI/default.htm. You can get this manual

and the advanced programming manual there, plus some other programs (when I put the links up).

22