|
|
| Line 1: |
Line 1: |
| {{About|the calculator programming language|the TI 99/4A home computer programming language|TI BASIC (TI 99/4A)}}
| | If you compare registry cleaners there are a amount of factors to look out for. Because of the sheer amount of for registry cleaners accessible on the Internet at the moment it can be quite effortless to be scammed. Something usually overlooked is that a few of these products will on the contrary end up damaging the PC. And the registry they state they have cleaned can simply cause more problems with the computer than the ones you started with.<br><br>Install an anti-virus software. If you already have that on we computer then carry out a full program scan. If it finds any viruses on the computer, delete those. Viruses invade the computer plus make it slower. To safeguard the computer from different viruses, it happens to be greater to keep the anti-virus software running whenever we use the internet. You can furthermore fix the security settings of the web browser. It might block unknown and risky websites and also block off any spyware or malware striving to receive into the computer.<br><br>So, this advanced dual scan is not merely among the better, yet it happens to be additionally freeware. And as of all this that various regard CCleaner one of the better registry products inside the market today. I would add that I personally choose Regcure for the easy reason that it has a greater interface plus I recognize for a fact that it is ad-ware without charge.<br><br>First, usually clean a PC and keep it free of dust plus dirt. Dirt clogs up all of the fans plus could result the PC to overheat. We have to clean up disk room inside purchase to create your computer run faster. Delete temporary and unnecessary files plus unused programs. Empty the recycle bin plus remove programs you're not using.<br><br>In a word, to speed up windows XP, Vista startup, it's very important to disable several startup goods and clean plus optimize the registry. We can follow the procedures above to disable unnecessary programs. To optimize the registry, I suggest we utilize a [http://bestregistrycleanerfix.com/tune-up-utilities tuneup utilities 2014] software. Because it is quite dangerous for you to edit the registry by yourself.<br><br>Why this issue happens frequently? What are the causes of it? In fact, there are 3 main causes which will lead to the PC freezing problem. To resolve the issue, we have to take 3 procedures inside the following paragraphs.<br><br>Another problem with the damaged adaptation is the fact that it takes too much time to scan the system plus while it's scanning, we cannot use the computer otherwise. Moreover, there is no technical help to these cracked versions that means should you receive stuck someplace, we can't ask for aid. They even never have any customer service aid lines wherein you can call or mail to resolve your issues.<br><br>Registry products have been tailored to fix all of the broken files inside the program, allowing your computer to read any file it wants, whenever it wants. They work by scanning through the registry and checking each registry file. If the cleaner sees it is corrupt, then it usually substitute it automatically. |
| '''TI-BASIC''' is the unofficial name of a [[BASIC]]-like language built into [[Texas Instruments|Texas Instruments (TI)]]'s [[graphing calculator]]s, including the [[TI-83 series]], [[TI-84 Plus series]], [[TI-89 series]], [[TI-92 series]] (including Voyage 200), [[TI-73]], and [[TI-Nspire]]. TI usually doesn't refer to the language by name, but the name TI-BASIC has been used occasionally in developer documentation.<ref>http://education.ti.com/educationportal/sites/US/productDetail/us_ti89ti.html?bid=5 TI-89 at education.ti.com</ref><ref>http://education.ti.com/nspire/scripting. Retrieved 2011-06-05.</ref>
| |
| | |
| For many applications, it is the most convenient way to [[computer programming|program]] any TI calculator, since the capability to write programs in TI-BASIC is built-in. [[Assembly language]] (often referred to as "asm") can also be used, and [[C (programming language)|C]] [[compiler]]s exist for translation into assembly: [[TIGCC]] for [[Motorola 68000]] (68k) based calculators, and [[Small Device C Compiler|SDCC]] for [[Zilog Z80]] based calculators. However, both of them are [[cross-compiler]]s, not allowing on-calculator programming. TI-BASIC is considerably slower than the assembly language (because it has to be interpreted), making it better suited to writing programs to quickly solve math problems or perform repetitive tasks, rather than programming games or graphics-intensive applications. Some math instruction books even provide programs in TI-BASIC (usually for the widespread variant used by the TI-82/83/84 series).
| |
| | |
| Although it is somewhat minimalist compared to programming languages used on computers, TI-BASIC is nonetheless an important factor in the programming community. Because TI graphing calculators are required for advanced mathematics classes in many high schools and universities, TI-BASIC often provides the first glimpse many students have into the world of programming.
| |
| {{wikibookshas|textbooks on TI-BASIC programming|
| |
| * ''[[b:Programming:TI-Basic|Programming:TI-Basic]]''
| |
| * ''[[b:TI-Basic Programs|TI-Basic Programs]]''}}
| |
| | |
| ==Syntax==
| |
| The syntax of all versions of TI-BASIC are somewhat different from typical BASIC implementations. The language itself has some basic [[structured programming]] capabilities, but makes limited to no use of or allowance for [[whitespace character|white space]] or indentation. It is also dependent on a somewhat non-standard [[TI calculator character sets|character set]], with specific characters for assignment (the right "STO" arrow, not readily available in most character sets), [[square root|square]] and [[cube root]]s, and other mathematical symbols, as well as [[tokenize]]d entry and storage for keywords. All statements begin with a colon, which also functions as a statement separator within lines. On the TI-83/84 models, closing parentheses, brackets, braces, and quotes can be omitted at the end of a line or before the STO token, although sometimes they are left on.
| |
| | |
| Expressions use [[infix notation]], with standard [[operator precedence]]. Many statements include their arguments in parentheses, similar to the syntax used for mathematical functions. The assignment syntax is unusual; rather than using a let statement or an equals sign, TI-BASIC uses a right-arrow "STO" operator with the syntax: ''source → destination''.
| |
| | |
| ===Control flow===
| |
| [[Control flow]] statements include [[conditional (programming)|if-then-else blocks]], [[for loop]]s, [[while loop]]s, and [[do while loop|repeat loops]], though no [[switch statement]]s. Unusual for a high level language, TI-BASIC implementations include IS> (Increment and Skip if Greater Than) and DS< (Decrement and Skip if Less Than) statements, constructs generally associated with [[assembly language]]s. Sections of programs can be [[Label (programming language)|labeled]]; however, particularly on the Z80 models, the labels function primarily as destinations for [[GOTO]] statements rather than as program or block labels.
| |
| | |
| Availability of functions and subroutines depends on the implementation; the versions available on the TI-82-descended calculators do not even support a [[GOSUB]]-like function, though it is possible to call programs from within each other and share variables between programs. TI-89/92-based designs can have access to shared functions, essentially programs capable of returning a value.
| |
| | |
| ===Data types===
| |
| TI-BASIC is a [[strong typing|strongly]] and [[dynamic typing|dynamically-typed]] language. Available data types differ considerably between the 68k and Z80 versions. It is not possible to create user-defined data types without using a library written in assembly. Lists are often used as a replacement for [[record (computer science)|structs]].
| |
| | |
| ====68k====
| |
| * Integers, which can store a large amount of data. The 68k calculators can store very large numbers, as high as <math>10^{600}</math>, with perfect accuracy.
| |
| * Real numbers, using [[decimal floating point]]. These store up to 14 significant digits depending on the calculator model.
| |
| * [[Complex numbers]], implemented as pairs of reals.
| |
| * [[String (computer science)|Strings]]
| |
| * Lists, which are one-dimensional [[Linked list|linked lists]] which support elementwise operations. On the 68k calculators, elements can be integers, reals, complex numbers, strings or expressions.
| |
| * [[Matrix (mathematics)|Matrices]], with elements subject to the same restrictions in lists
| |
| * [[Symbolic computation|Symbolic expressions]], unique to the 68k series.
| |
| | |
| Data types that cannot be directly manipulated (typing only their name on a line would result in an error) include:
| |
| * Pictures
| |
| * Data
| |
| * Programs
| |
| * Functions
| |
| | |
| ====TI-83/84 (Z80)====
| |
| * Numerical [[variable (programming)|variables]], including <code>A</code> - <code>Z</code> and <code>[[theta|Θ]]</code> (theta). These allow [[real number]]s or [[complex number]]s (implemented as pairs of reals) to be stored in [[floating point]] format. Values may range from 1<small>E</small>-99 to 1<small>E</small>99 with up to ten digits of accuracy. The limit of 27 variables, however, may be expanded through the use of lists or matrices, as a programmer can define each element in a list or matrix as a unique real variable and reference it accordingly.
| |
| * [[String (computer science)|Strings]], including <code>Str0</code> - <code>Str9</code>. These may store any number of characters or even function names, as long as there is available memory. They can be evaluated as an expression with the expr() function, which is found in the catalog.
| |
| * Lists, including <code>L<small>1</small></code> - <code>L<small>6</small></code>, with the ability to create additional ones. These are essentially [[one-dimensional]] [[array data type|arrays]] used to store a real or complex number into each of their [[array data structure|elements]]. The [[dimension]] of a list, its number of elements, may range from 1 to 999, although [[available]] [[Random-access memory|memory]] may be a [[limiting factor]]. When a list's dimension is set lower than it previously was, elements at the end are cut off. When set higher, extra elements at the end are filled with zeros. Dimensions are set by storing a valid number into the <code>dim(</code> of the list name. The default lists are named L<small>1</small>–L<small>6</small>, but custom lists can be created. This is done by setting dimension of a list referenced with the <small>L</small> [[lexical analysis#Token|token]] (accessible by pressing <code>[2nd]+[LIST(STAT)]</code>, under the <code>OPS</code> menu as item <code>B:</code>), followed by a name ranging from 1 to 5 [[character (computing)|characters]] that begins with an uppercase letter (A–Z) or Θ. Individual elements of lists can be accessed by placing the element number in [[Bracket#Parentheses_.28_.29|parentheses]] after the list name.
| |
| * [[Matrix (mathematics)|Matrices]], including <code>[A]</code> - <code>[J]</code>. Their elements are subject to the same restrictions as lists. Their dimensions may be defined up to 99x99 elements, although, again, available memory will limit this. It is not possible to create user-defined matrices, so only the ten built in ones may be utilized.
| |
| * Equation variables, including <code>Y<small>0</small></code> - <code>Y<small>9</small></code>, <code>r<small>1</small></code> - <code>r<small>6</small></code>, and <code>u</code>, <code>v</code>, <code>w</code>. These are essentially strings which store equations. They are evaluated to return a value when used in an expression or program. Specific values can be plugged in for the independent variable by following the equation name by the value in parentheses. (<code>Y<small>1</small></code>(4) would return the value of <code>Y<small>1</small></code> at X=4)
| |
| | |
| Data types that cannot be directly manipulated (typing only their name on a line would result in an error) include:
| |
| * Pictures (<code>Pic0</code> - <code>Pic9</code>)
| |
| * Programs (<code>Prgm</code>)
| |
| * Graph databases (<code>GDB0</code> - <code>GDB9</code>)
| |
| | |
| Examples:
| |
| :16→A "Store the value of 16 into variable A."
| |
| :B+1→B "Increment the relative value of B by 1."
| |
| :−1.3+4.9i→Θ "Store the value of negative 1.3 plus 4.9i into variable theta (Θ)."
| |
| | |
| :25→dim(L<small>1</small>) "Set the dimension of list L<small>1</small> to 25, so it has 25 elements."
| |
| :999→dim(L<small>6</small>) "Set the dimension of list L<small>6</small> to its maximum of 999."
| |
| :0→dim(L<small>2</small>) "Will return an error because zero is not a valid list dimension."
| |
| | |
| :Disp L<small>1</small>(4) "Yields the value of the fourth element of List 1."
| |
| :15→dim(<small>L</small>MYLST) "Creates a new list named MYLST with 15 default elements (filled with zeros)."
| |
| :9→<small>L</small>MYLST(3) "Stores the value of nine into the third element of list MYLST."
| |
| :Disp <small>L</small>MYLST(3) "Displays '9'."
| |
| | |
| ===Variables===
| |
| Flexibility in the use of variables varies widely by the calculator model. The 68k calculators allow all variable names to have up to eight alphanumeric (including [[Greek alphabet|Greek]]) characters. Furthermore, variables can be grouped into "folders", or made [[local variable|local]] to a program (by declaring them with the <code>Local</code> statement). In contrast, on the TI-83, the programmer can create lists whose names are up to five characters. All other data types are limited, such as the 27 real or complex variables (A-Z and [[Θ]]), and a number of predefined variable names of other types (e.g., matrices have to be one of the ten variables <code>[A]</code>-<code>[J]</code>). Also, all variables are global.
| |
| | |
| ===Comments===
| |
| The 68k calculators allow programs to include single-line [[comment (computer programming)|comments]], using [[copyright symbol|©]] as a comment symbol. If a comment appears as the first line after the "Prgm" statement, it is displayed in the status bar when the program is selected in the catalog; such comments are often used to document the names or types of parameters.
| |
| | |
| Z80 programmers often start lines with " (double quotation mark) to denote a comment. Lines starting with " are actually executed, assigning the contents of the comment to the <code>Ans</code> variable, but this doesn't affect anything other than performance unless the <code>Ans</code> variable is read right afterwards.
| |
| | |
| ===Functions===
| |
| The 68k version of TI-BASIC allows creating user-defined functions. Functions have the same syntax as programs except that they use the <code>Func</code>...<code>EndFunc</code> keywords instead of <code>Prgm</code>...<code>EndPrgm</code>, and that they are not allowed to use instructions that perform I/O, modify non-local variables, nor call programs. However, functions can still be non-[[pure function|pure]] because they can call built-in functions such as <code>getTime()</code>, <code>getKey()</code>, or [[pseudorandom number generator|<code>rand()</code>]].
| |
| | |
| All functions have a return value, which in the absence of an explicit <code>Return</code> statement is the last expression evaluated.
| |
| | |
| ===Third-party language extensions===
| |
| Third-party applications, in chronological order Omnicalc,<ref>ticalc.org. [http://www.ticalc.org/archives/news/articles/6/62/62080.html Omnicalc v1.00 Released]</ref> xLIB,<ref>Evans, Travis. [http://www.ticalc.org/archives/news/articles/14/146/146528.html xLIB by Patrick Prendergast]</ref> Celtic, and Doors CS,<ref>Sutherland, Nikky. [http://www.ticalc.org/archives/news/articles/14/146/146642.html Find an Oasis in Doors CS 7.0]</ref> have overloaded TI-BASIC functions on the Z80 calculators to provide additional language functionality. The third-party libraries overload the <tt>sum()</tt>, <tt>real()</tt>, <tt>det()</tt> and <tt>identity()</tt> functions, which are handled and interpreted by their respective applications. Among the extra functions are fast shape-drawing routines, sprite and tilemap tools, program and VAT modification and access abilities, GUI construction features, and much more, most of which are ordinarily restricted to use by assembly programmers. All of the functions require that an application like [http://www.ticalc.org/archives/files/fileinfo/430/43068.html Doors CS 7.0] be present on the user's calculator, sometimes considered a detraction to the use of the libraries.
| |
| | |
| ==Examples==
| |
| These examples are slightly TI-83-series biased. For example, "ClrHome" would be "ClLCD" on the [[TI-85]] and [[TI-86]].
| |
| | |
| An entirely different command is required to clear the screen in the [[TI-89]]. Since output is generally displayed on the ProgramIO screen, the "ClrIO" command is required to clear the output screen. There exists a "ClrHome" command on the TI-89, and it performs its function - namely, clearing the Home screen. For programming purposes, however, this command is essentially useless.
| |
| | |
| ===Hello world===
| |
| The following program, when executed, will display the phrase "<code>[[Hello world program|HELLO, WORLD!]]</code>":
| |
| | |
| Z80 Series
| |
| PROGRAM:HELLOWLD
| |
| :ClrHome
| |
| :Disp "HELLO, WORLD!"
| |
| | |
| 68k Series
| |
| hellowld()
| |
| :Prgm
| |
| : ClrIO
| |
| : Disp "HELLO, WORLD!"
| |
| :EndPrgm
| |
| | |
| TI-Nspire
| |
| text"HELLO, WORLD!"
| |
| | |
| TI-Nspire CX
| |
| text "HELLO, WORLD!"
| |
| | |
| or
| |
| | |
| Disp "HELLO, WORLD"
| |
| | |
| ===Lists and loops===
| |
| | |
| ====Lists====
| |
| TI-82 Series Z80
| |
| | |
| PROGRAM:LISTS
| |
| :Input "NUMBER OF VARS? ",A
| |
| :If A<1 or fPart(A)
| |
| :Stop
| |
| :For(N,1,A)
| |
| :Input "VAR ",B
| |
| :B→L<sub>1</sub>(N)
| |
| :End
| |
| :L<sub>1</sub>
| |
| | |
| TI-85/86 Z80
| |
| PROGRAM:Lists
| |
| :Input "Number of variables? ",A
| |
| :If A<1 or fPart A
| |
| :Stop
| |
| :For(N,1,A)
| |
| :Input "Var ",B
| |
| :B→L1(N)
| |
| :End
| |
| :L1
| |
| | |
| 68k Series
| |
| | |
| lists()
| |
| :Prgm
| |
| : Local n,i,c
| |
| : {}→list
| |
| : Input "Number of variables?",n
| |
| : For i,1,n
| |
| : Input "Variable #"&string(i),c
| |
| : c→list[i]
| |
| : EndFor
| |
| :EndPrgm
| |
| | |
| In addition, lists are important for saving save game data and highscore data in programs. This is better than storing highscore or save game information as a variable, as variables are commonly changed during calculations performed by the user. Lists on the TI-82 cannot have custom names (L<sub>1</sub> through L<sub>6</sub> are preprogrammed). The TI-85 and TI-86 do not have the ability to handle a variable name with subscripts. The TI-81 is completely unable to handle lists. | |
| | |
| ====Elaborations====
| |
| Essentially, this program can be used to compile a list containing an arbitrary number of elements, which could then be implemented in a larger program that would break up the list and put each element to use. For instance, if we were to create a polynomial equation solver, we would use the technique noted above to compile all the coefficients into a list. Under the guidelines of the [[Rational root theorem|Rational Root Theorem]], we would implement the first and last elements into a program to be factored and paired (and put into another list). To finish, we would create another While loop which would take the list with the factored elements, raise them to the appropriate power (this can be done by finding the "dim(L1)", subtracting one from it, and implementing another While loop which would subtract from the "dim(L1)" with intervals of 1), multiplying the result to the elements of the original list, adding the new results, and checking to see if the sum (of the new result) is equal to 0.
| |
| | |
| The "If A<1 or fPart(A)" statement checks to see if the variable A is a negative number, is zero or a non-integer. If so, the program is stopped by the Stop statement. If the condition is not true, then the program continues on to the rest of the code. The first variable is used to define L1. In the [[For loop]], N is first set to 1, then the For loop will continue while N is less than or equal to A. After every iteration of the For loop, N will increase by 1. Every time the For loop is executed, an input is asked for, and the element is added to the end of the list, and saved. By this time, the list L1 should have a dim(L1) = A (the length of the list is A) and be ready for manipulation.
| |
| | |
| ====Counting====
| |
| Z80 Series
| |
| PROGRAM:COUNTING
| |
| :ClrHome
| |
| :10^10→B
| |
| :For(A,1,B)
| |
| :Output(1,1,A)
| |
| :End
| |
| | |
| 68k Series
| |
| counting()
| |
| :Prgm
| |
| : Local a,b
| |
| : 10^10→b
| |
| : For a,1,b
| |
| : Disp a
| |
| : EndFor
| |
| :EndPrgm
| |
| | |
| ==== Explanation of Z80 counting code ====
| |
| This program defines the variable B, as (10^10). In the Z80 version, a "For loop" is established, which will store each successive number from 1 through B (10^10) in variable A.
| |
| | |
| The program then outputs the data currently stored in Variable A, to character space 1,1 in the screen (Top left corner).
| |
| | |
| A Clrhome refresh is not required, because each successive "A" variable which is outputted to character space (1,1) will replace the previous value on the screen which was there.
| |
| | |
| This loop will continue until the value of variable "A" is equivalent to the value of Variable "B", at which point the program will end.
| |
| | |
| ===Recursion===
| |
| Recursion is possible. A program can be called from within itself or from within another program.
| |
| | |
| Z80 Series
| |
| | |
| PROGRAM:FACTUI
| |
| :"A user interface for FACT"
| |
| :Prompt X
| |
| :1→A:"An accumulator of sorts. The answer will be stored here."
| |
| :prgmFACT
| |
| | |
| PROGRAM:FACT
| |
| :If X=0
| |
| :Then
| |
| :Disp A
| |
| :Stop
| |
| :End
| |
| :XA→A
| |
| :X-1→X
| |
| :prgmFACT
| |
| | |
| 68k Series
| |
| | |
| factui()
| |
| :Prgm
| |
| : Local fact, n
| |
| : Define fact(x)=Func
| |
| : If x=0
| |
| : Return 1
| |
| : Return x*fact(x-1)
| |
| : EndFunc
| |
| : Input "Input a number", n
| |
| : Disp "n! = "
| |
| : Disp fact(n)
| |
| :EndPrgm
| |
| | |
| ===Functions===
| |
| The 68k series makes a distinction between programs and functions. Functions are just like programs except that they do not allow statements with side effects (like Input or Disp, nor modifying non-local variables), and they return a value, which in the absence of an explicit Return statement is the last expression evaluated.
| |
| | |
| fact(x)
| |
| :Func
| |
| : If x=0
| |
| : Return 1
| |
| : If x<0
| |
| : Return undef
| |
| : x*fact(x-1)
| |
| :End Func
| |
| | |
| ==Editors and Tools==
| |
| The growth of the hobbyist graphing calculator community in the 1990s brought with it sharing and collaboration, including the need to share TI-BASIC code on mailing lists and discussion forums. At first, this was done by typing out the TI-BASIC code from a calculator screen into a computer by hand, or conversely, entering programs manually into calculators. TI-BASIC programs are stored in a [[Tokenization|tokenized]] format, they cannot be edited using standard computer text editors, so as the calculator programming community matured, a need for an automated converter arose. The format for computer-stored TI-BASIC programs generated by Texas Instruments' TI-GraphLink application was eventually decoded, and third-party tools were created to manipulate these files. TI created a BASIC editor that they included in certain releases of the TI-GraphLink linking program, but it has not gained widespread usage. In particular, it used a custom character set that did not display properly when copied and pasted to fora. In 2005, United-TI member Joe "Brazucs" Penna (now known as [[Joe Penna|MysteryGuitarMan]]) created a translator in PHP that would convert text from the TI-GraphLink editor into standard Unicode, a project that soon expanded to include a regex-based TI-BASIC optimizer.<ref>{{cite web|url=http://www.cemetech.net/projects/uti/viewtopic.php?t=3680| title=Cemetech – United-TI Archives – Project Ideas/Start New Projects – opTI-BASIC [Topic]| publisher=Cemetech archive of UnitedTI | accessdate=2012-08-05}}</ref>
| |
|
| |
| Independently, Christopher "Kerm Martian" Mitchell of [[Cemetech]] began creating an online converter to extract plain-text (and later HTML and [[BBCode]]-formatted) contents from tokenized TI-BASIC programs,<ref>{{cite web|url=http://www.ticalc.org/archives/news/articles/13/132/132993.html| title=Martian Develops SourceCoder; Conquers BASIClings| author="Michael Vincent" | publisher=ticalc.org | accessdate=2012-08-05}}</ref> which expanded to include an online program editor, exporter, and TI-83 Plus emulator.<ref>{{cite web|url=http://www.ticalc.org/archives/news/articles/14/146/146444.html| title=Cemetech's SourceCoder Updated| author="Travis Evans" | publisher=ticalc.org | accessdate=2012-08-05}}</ref> The SourceCoder project absorbed OptiBASIC at the end of 2005. The only other major TI-BASIC editor currently in use is TokenIDE (or "Tokens"), created by Shaun "Merthsoft" McFall. An offline editor, Tokens can import, edit, and export TI-BASIC programs, includes tools to track program size and correctness, and offers ancillary features such as a sprite/image editor. Built around token definitions stored in [[XML]] files, it is intended to be extensible to work with any user-specified token mapping.<ref>{{cite web|url=http://www.ticalc.org/archives/news/articles/14/148/148184.html| title=TokenIDE / Shaun McFall Interview| author="Ryan Boyd" | publisher=ticalc.org | accessdate=2013-01-18}}</ref>
| |
| | |
| ==See also==
| |
| * [[Calculator gaming]]
| |
| * [[Programmable calculator]]
| |
| * [[RPL (programming language)]]
| |
| | |
| ==References==
| |
| {{Reflist|30em}}
| |
| | |
| ==External links==
| |
| *[http://education.ti.com/ Texas Instruments' official website]
| |
| *[http://tibasicdev.wikidot.com/ TI-Basic Developer]
| |
| *[http://www.cemetech.net/projects/basicelite/sourcecoder2.php SourceCoder Online TI-BASIC editor]
| |
| | |
| {{TI-calc}}
| |
| | |
| {{DEFAULTSORT:Ti-Basic}}
| |
| [[Category:Texas Instruments calculators]]
| |
| [[Category:Articles with example BASIC code]]
| |
| [[Category:Graphing calculators]]
| |
| [[Category:BASIC interpreters]]
| |
| [[Category:Unofficial names]]
| |
