TI-89 BASIC Programming

TI-89 BASIC Programming TI-89 BASIC Programming

By Karl Voelker

What is TI-89 BASIC?

It's not really BASIC. That's just what people call it.

It's also not very similar to TI-83 or TI-86 BASIC.

It is:

Dynamically typed
Strongly typed
Procedural

Interactive Mode

Many interpreters provide an "interactive mode" where you enter individual lines of code and see the result.

On a TI-89, the "Home Screen" is the interactive mode of the BASIC interpreter.

The I/O Screen

Unlike the TI-83/86 home screen, the TI-89 home screen is not the input/output console for programs.

The TI-89 has a separate I/O Screen for this purpose.

Files

Since the entire TI-89 environment is a BASIC interpreter, files are just global variables.

Global variables keep existing when you turn off the calculator.

Folders

TI-89 folders can also be used as namespaces for global variables.

TI-89 folders can not be nested.

Program Entry

When you are entering a program, you can type function names.

Once you are a proficient typist, this will be faster than finding functions in the menus.

Function names are case-insensitive.

Function name case is corrected when you run your program.

Typography

The TI-89 font is strange. I will be using these characters in place of actual TI-89 characters:

`->`	Arrow
`\|>`	Arrow-like triangle, used in names of some conversion functions

The Colon

The colon separates statements.

In the Program Editor, each line implicitly begins with a colon.

Data Types

We will go into the details of each of these:

NUM
STRING
LIST
MAT
PRGM
FUNC

This is the numeric type. It may hold:

An integer
An exact algebraic value
An approximate decimal value

<tt>STRING</tt>

A string is mostly what you'd expect.

Strings are delimited by double quotes.

List/matrix items must be scalar
Lists and matrices can have a mix of scalar types
Once created, a list/matrix is a fixed size
Lists/matrix indices start at 1

Creating a list

{0, 0, 0}
newList(3, 0)

Creating a matrix

[[0, 0, 0][0, 0, 0]]
[0, 0, 0; 0, 0, 0]
newMat(3, 2, 0)

A "program" can act as a program or subprogram.

A program cannot return a value.

A global program variable:

:foo(bar,baz)
:Prgm
:dostuff()
:EndPrgm

Note: use the Program Editor application to create a new global program.

Variables

Assign to a variable with ->:

:4->x
:4+x->x

Variables are global by default!

To declare a local variable:

:Local x
:4->x

Local Subprograms

You can create a subprogram in a local variable, but:

Programs are secretly compiled when changed
Compiled form of local program is lost when it goes out of scope
This is slow!

A local program variable:

:Local foo
:Define foo(bar,baz)=Prgm
:dostuff()
:EndPrgm

A function is like a program, but:

It cannot modify non-local variables
It must return a value
It is delimited with Func and EndFunc

To return a value:

Explicitly, with Return x
Implicitly, as the value of the last executed statement

The Conditional Statement

TI-89 is not a part of the World Government conspiracy.

An example:

:If x>5 Then
:5->x
:ElseIf x<0 Then
:0->x
:Else
:2*x->x
:EndIf

The Conditional Function

The condition function is when:

:when(x>5,5,x)->x

Loops

The For loop:

:For i,begin,end,step
:dostuff()
:EndFor

The While loop:

:While more()
:dostuff()
:EndWhile

More About Loops

The infinite loop:

:Loop
:dostuff()
:EndLoop

Loop control:

:Cycle: Skip to next iteration of loop
:Exit: Exit a loop

Errors

Trap errors with Try:

:Try
:foo/bar->x
:Else
:ClrErr
:0->x
:EndTry

Errors, continued

In the Else block, use one of these:

ClrErr: The error was handled
PassErr: The error was not handled

The system variable errornum will contain an error code.

Numeric operations

There are many numeric operators and functions built-in.

If you don't want exact algebraic values, use approx.

Comparisons

Individual characters exist for many comparisons:

Comparison	Type
Equal	`=`
Not equal	`Diamond =`
Less than	`2nd 0`
Less than or equal	`Diamond 0`
Greater than	`2nd .`
Greater than or equal	`Diamond .`

These work on strings!

Logical Operators

The logical operators are words (but still infix).

They are:

and
or
xor
not (also ~) (prefix)

String Operations

Concatenate strings with &.

Useful string functions:

left("foobar", 3): Substring from left
mid("foobar", 2, 2): Substring from anywhere
right("foobar", 3): Substring from right

More String Operations

dim("foo"): Length
inString("foobar", "oo"): Search for substring
expr("3+4"): Evaluate BASIC expression in a string
string(3): String representation of a value

List and Matrix Indices

To access an item:

mylist[3]
mymat[3,4]

Give only the first index for a matrix to get that row.

List and Matrix Functions

augment: Concatenate lists or matrices
subMat: Extract any rectangular submatrix
dim, left, mid, right: Work on list items just like they do on string characters
list|>mat: Convert a list to a matrix
mat|>list: Convert a matrix to a list

Output Statements

:Disp "foo": Display a string, with trailing newline
:Output 0,0,"foo": Display a string at a pixel location
:ClrIO: Clear the I/O screen

Input Statements

:Pause "message": Wait for a keypress
:Input "message",x: Input an expression
:InputStr "message",x: Input a string

Indirection

The # operator (prefix) takes a string and accesses the variable named by the string's contents.

This gives you power similar to references or pointers.

Further Topics

Someday, this presentation might cover these topics:

Dialog boxes
Menus
Link communication

For now, at least you know that they are possible in TI-89 BASIC.

The End

Questions?