Binary To Decimal

Routine Summary

Converts a binary (base 2) number to a decimal (base 10) number.

Inputs

Ans - The binary number that you want to convert expressed as a list, stored in Ans.

Outputs

Ans - The decimal representation of the binary number.

Variables Used

Ans, A

Calculator Compatibility

TI-83/84/+/SE

Author

imcoraline

:sum(seq(Ans(dim(Ans)-A)2^A,A,0,dim(Ans)-1

This routine takes a positive whole binary number (base 2), expressed as a list, and converts it to the equivalent decimal (base 10) representation. To express a binary number in a list, you simply put commas in between each digit, and then surround that with list brackets. For example, the binary number 101101 expressed a list would be {1,0,1,1,0,1}. To learn how to convert a binary number to a decimal number, vice versa, and even see how to convert to and from other bases besides binary and decimal, see the Binary and Hexadecimal page.

It also may be important to note that adding 0’s to the front of a binary number will not change the decimal equivalent. For example, both 01101012 and 1101012 are equivalent to 5310.

Error Conditions

  • ERR:DATA TYPE is thrown if the list has an imaginary number in it.
  • An error will not be thrown the list is not a binary number, or if any element in the list is negative or non-whole. Nonetheless, the conversion will not work correctly.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/binary-to-decimal


Blinking Text

Routine Summary

Creates a blinking effect on the home screen.

Inputs

Str1 - the text to blink on the screen
A,B - the Output( coordinates for the text
N - the length of the text to be displayed

Outputs

None

Variables Used

Str1, N, A, B, Ans

Calculator Compatibility

TI-83/84/+/SE

Download

blink.zip

:length(Str1→N:1
:Repeat getKey
:If dim(rand(15
:Output(A,B,sub(Str1+" (N spaces) ",1+NAns,N
:not(Ans
:End

By leaving 1 by itself on one line, we store it to Ans, which will be easier to work with. Then, the Repeat getKey loop will keep blinking the text until a key — any key — is pressed.

Output(A,B,sub(Str1+" (N spaces) ",1+NAns,N will display either the text or the equivalent number of spaces on the screen at coordinates (A,B). If you want to blink the text "Hello", for example, then you would need to use five spaces. We negate Ans's value with not(, which acts as a flag to control the blinking.

If dim(rand(15 is a clever way of delaying the blinking, so that it doesn't blink too fast. rand(15 generates a list of 15 random numbers, which is a slightly time-consuming process. If dim( is just a way of wrapping this list so it doesn't change Ans. Since dim(rand(15 is always 15, the If statement will always be true, so we don't have to worry about the next line being skipped. By changing 15 to a lower or higher number, you can make the blinking go faster or slower, respectively.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/blinking-text


Custom Menu - Graph Screen
GraphMenu.png

Routine Summary

This routine is used for creating complex graphical menus. It can have hundreds of sub-menus, and works quite similarly to a menu on the home screen.

Inputs

Str1 - A list of menu options, each being of length L
L - The length of the sub-strings for the current menu
N - The number of options in the current menu
O - The menu identifier
S - The current item/row selected

Outputs

The variable(s) that the routine stores to at the end.
O - The menu identifier
S - The current item/row selected

Variables Used

Str1 - A list of menu options, each being of length L
L - The length of the sub-strings for the current menu
N - The number of options in the current menu
O - The menu identifier
S - The current item/row selected
K - A keystroke identifier
Xmin - Graph Settings
Xmax - Graph Settings
Ymin - Graph Settings
Ymax - Graph Settings
Theta - For Loop Counter
Z - For Loop Counter
GDB1 - Cleanup Variable

Calculator Compatibility

TI-83/84/+/SE

Author

Trenly

StoreGDB 1
Lbl M0
ClrDraw
AxesOff
GridOff
ClrHome
62→Ymax:0→Ymin
94→Xmax:0→Xmin
"1:Option 2:Option3:Option "→Str1
0→O:1→S:8→L:3→N
Lbl M
Text(0,0,"Custom Menu Beta 0.1"
Horizontal Ymax-7
For(θ,0,N-1
Text(8+7θ,0,sub(Str1,1+Lθ,L)
End
Horizontal Ymax-9-7N
For(θ,6,1,⁻1
For(Z,0,4
Pxl-Change(8+7S-θ,Z
End
End
Repeat sum(K={23,45,105
Repeat sum(K={23,45,105,34,25,72,73,74,82,83,84,92,93,94
getKey→K
End
If K=34(S<N) or K=25(S>1
Then
For(θ,6,1,⁻1
For(Z,0,4
Pxl-Change(8+7S-θ,Z
End
End
S+(K=34)-(K=25)→S
For(θ,1,6
For(Z,0,4
Pxl-Change(8+7S-θ,Z
End
End
End
If sum(K={72,73,74,82,83,84,92,93,94
Then
K-13int(K/13(2>abs(5-abs(5-abs(K-83
If Ans≤N and Ans>0
Then
Ans→S
105→K
End
End
End
ClrDraw
ClrHome
If (K=23)O:Goto M0
If (K=23)not(O:Goto E
If K=45:Goto E
If (O=0)(S=1:Goto M1
If (O=0)(S=2:Goto M2

--Add an if statement here for each option you have--
-- O defines which menu you are currently in --
-- S defines the option they selected --

Lbl E
ClrDraw
RecallGDB 1
ClrHome
Return

This menu is made for the graphscreen on monochrome calculators. It functions similarly to the Menu( command, in that it highlights the current menu option, and uses labels. To create your own menus, each menu needs a menu id, a string containing entries of the same length, the number of entries, the length of the entries, and the starting selection. What makes this code functional is that each menu option is referenced by a menu ID, and the number of the selection. Because of this, the same code can be used to display multiple menus.

In addition to the up and down arrows and enter, a user can use the numberpad to select an option. The clear key will exit the program from any menu, and the delete key will return to the main menu from inside any menu. If the delete key is used on the main menu, the program will end.

The main menu has an ID of 0 by default, and can be shown at any time using "Goto M0". Any sub-menus you wish to add should be in the following format. You will need to change O, L, and N for each menu. In the code below, O is set to 1. This is what gets referenced in the If statements in the main code. S is set to 1 since I want the first option to be selected when we load the menu. L is set to 22 in this example because each menu option is 22 characters long. You will notice there are spaces included to make sure each item is the same length. Finally, there are 6 options in this example, so N is set to 6. We then Goto M to display the menu

Lbl M1
"1:Kilograms◄ ►Lbs     2:Meters◄ ►Feet       3:ElectronVolt◄ ►Joule4:Joule◄ ►Calorie     5:Horsepower◄ ►Watt   6:Back                →Str1
1→O:1→S:22→L:6→N
Goto M

Error Conditions

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/custom-menu-graph-screen


Custom Menu Multi Page
wabbitemu.gif

Routine Summary

A custom menu with up to 9 switchable pages.

Inputs

Str1-Str9 - one string per page
A - Number of pages the menu includes

Outputs

B - the page they're on
X - the # choice they made

Variables Used

Ans, B, C, D, X, Str#

Calculator Compatibility

TI-83/84/+/SE

Author

Mr Dino

Download

MENUZ.zip

:1→B
:While 1
:If B=1:Str1
:If B=2:Str2
:If B=3:Str3
:If B=4:Str4
:If B=5:Str5
:If B=6:Str6
:If B=7:Str7
:If B=8:Str8
:If B=9:Str9
:ClrHome
:Output(1,1,Ans
:length(Ans)/16
:If fPart(Ans
:1+iPart(Ans
:Ans→D
:2→X
:Repeat C=24 or C=26
:Output(X,2,">
:Repeat Ans
:getKey→C
:End
:If Ans=21
:Then
:X-1→X
:Return
:End
:Output(X,2," " // space
:X-(Ans=25)+(Ans=34→X
:2(X>D)+D(X≤1)+X(X≤D and X>1→X
:max(1,min(A,B+(C=26)-(C=24→B
:End
:End

To use this code, store an integer to A 1-0 representing the number of pages that will be in your menu. It will use all strings Str1-StrA. Next, store the menu pages into the strings. They will be shown with 'Output(1,1,StrA)', so make sure that the menu looks right before using it. Make sure there are 16 characters in each line (starting with the title). Use spaces to make the words fit right, and you should probably test it to make sure it works. There should probably also be something in the title that signifies what page you're on. Finally, run the code as a subprogram.

Here's how it works:

B represents what page number it's on, so we start off by storing 1 to B to put us on page 1. Then we have a While 1 loop to manage page changes. Based on the value of B, it will put one of the strings into Ans. It will output Ans onto the home screen, then determine how many rows are in the menu and store that to D. And the user will always start out on option 1 - row 2 (because of the title screen).

Now we start the choice loop: We display the cursor, then wait for a keypress. If the use presses [2nd], we subtract 1 from X (for the offset from the title) and Return back to the parent program, with B as the page number and X as the choice number. But if not, it continues: The cursor is erased, X and B are changed according to the keypress, and if the use changed the page, it exits the choice loop and enters the page loop where it displays the new page and sets up for another choice loop.

Error Conditions

It won't work properly if A isn't an integer within the bounds 1-9 or if the strings don't represent the menu pages correctly.

Related Routines

There are several routines that are similar in functionality or are used in a similar context. Make a bulleted list of them, with links to the other routines' pages. It will often be the case that several routines all link to each other.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/custom-menu-multi-page


Day of Week

Routine Summary

Calculates the day of week of a date, without using dayOfWk( (because it's only available on the 84+ and 84+SE)

Inputs

D - The day
M - The month
Y - The year (1950 through 2049)

Outputs

Ans - 0-6 = the day of week (Sunday - Saturday)

Variables Used

D, M, Y, Ans

Calculator Compatibility

TI-83/84/+/SE

Download

weekday.zip

:round(7fPart(dbd(101.5,DE2+M+fPart(.01Y))/7

Using the dbd( command, we return the number of days between the given date and January 1, 1950, our base date. dbd('s argument, in this case, is of the form DDMM.YY, so we put the date we're given in that form with DE2+M+fPart(.01Y. Once we have the number of days between the two dates, we divide it by seven (as there are seven days in a week) to get the number of weeks.

However, we are not interested in the number of weeks between two dates, we are interested in how far into the week we are. That would be the fractional part of the number of weeks. For example, if there was fourteen days between two dates (the first date being a Sunday) and we divide that by seven, we would have the equation 14/7=2.00. The .00 means that the week hasn't yet begun (and so, the day is Sunday).

If there was 15 days between two dates, the equation would give 15/7=2.1428571. The .1428571 means that we are .1428571 into the week, and if we multiply that by seven, we get the equation .1428571*7=1. This means that we are one day into the week (and so, the day is Monday). So in our formula, after finding out the number of days between two dates, we find the fractional part of it, and multiply that by seven. Finally, round( gets rid of any minor rounding errors.

As the 1st of January, 1950 was a Sunday (which is the date we have inputed into the above routine), so the number of days into the week will always be relative to Sunday. That is, the output 0 through 6 is relative to the days Sunday through Saturday respectively. If you want 0 to be Monday instead, make the base date January 2 instead by changing 101.5 to 201.5.

This routine can handle dates from January 1, 1950 to December 31, 2049. For other dates, it will assume the year is in that range instead. There is also an alternative routine that handles dates in an unlimited range.

Display Day

Append the following code to display the day of the week:

:Disp sub("SUNDAY***MONDAY***TUESDAY**WEDNESDAYTHURSDAY*FRIDAY***SATURDAY*",9Ans+1,9      //replace *s with spaces

Or this code, which should display the day of the week, only the display method takes less space and space pads it.
Disp sub("***SUN***MON**TUESWEDNES*THURS***FRI*SATUR",6Ans+1,6)+"DAY       //replace *s with spaces

Error Conditions

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/day-of-week


Decimal to Base B

Routine Summary

Converts a decimal (base 10) number to a number in any other integer base B.

Inputs

A - The decimal number that you want to convert.
B/ - The base you want to convert A into.

Outputs

Ans - The base B representation of the decimal number, in list form.

Variables Used

{$variable}

Calculator Compatibility

TI-83/84/+/SE

Author

imcoraline

Download

[{$download}]

:iPart(ln(A)/ln(B
:BfPart(int(AB^(cumSum(binomcdf(Ans,0))-Ans-1))/B

This routine takes a positive whole decimal number (base 10), stored in A, and converts it to the equivalent representation in base B. The representation will be in list form. For example, the decimal number 32 is the base 2 number 100000, meaning the routine would result in the list {1,0,0,0,0,0}.

Note: This routine will not work for A<B.

It also may be important to note that adding 0’s to the front of a number will not change the decimal equivalent. For example, both 01101012 and 1101012 are equivalent to 5310.

Error Conditions

  • ERR:DATATYPE is thrown if A is complex or negative.
  • ERR:DOMAIN is thrown if A is 0 or less than B.
  • An error will not be thrown is A isn’t an integer. Nonetheless, the conversion will not work correctly.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/decimal-to-binary


Decimal to Fraction

Routine Summary

Converts a decimal number to a fraction.

Inputs

Ans - the number you want to convert to a fraction

Outputs

Ans - the fraction in list format

Variables Used

Ans, X

Calculator Compatibility

TI-83/84/+/SE

Author

Weregoose

URL: United TI

Download

decimaltofraction.zip

:Ans→X:{1,abs(Ans
:Repeat E‾9>Ans(2
:abs(Ans(2){1,fPart(Ans(1)/Ans(2
:End
:round({X,1}/Ans(1),0
:Ans/gcd(Ans(1),Ans(2

Although there is a ►Frac command available for converting a decimal number to a fraction, this is only a formatting command and doesn't actually give you the numerator and denominator as separate numbers. This limits your choices for using fractions, especially since ►Frac only works with the Disp and Pause commands. In addition, it does not work very well, and fails for several inputs that you would think are within its ability to figure out (such as -1.3427625). Fortunately, you can improve upon the ►Frac command by using your own routine.

The basic algorithm that you use when converting a number to a fraction is commonly known as the Euclidean algorithm. While it has been around for literally millennia, it is still one of the best algorithms because of its sheer simplicity (it doesn't require any factoring or other complex math operations).

The way it works is that you have two numbers (in our routine, it's one and the decimal number you input), and you divide the first number by the second number, and check to see if there is a remainder. If there is a remainder, you then repeat the process again, except this time you swap the numbers. This process is repeated over and over again until the second number is equal to zero, at which point you will have your desired fraction.

One thing you will probably notice is that we aren't actually checking for zero in the Repeat loop. Because of the way that TI designed the TI-Basic language, each number has a limited amount of precision. As a result, any math calculations that involve extremely small or large numbers will produce rounding errors that don't return the right number. The easiest way to deal with this problem is by checking for a really small number (in this case, E‾9).

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/decimal-to-fraction


Deck of Cards

Routine Summary

Simulates a standard 52-card deck of cards.

Inputs

None

Outputs

∟DECK - the cards, in the format:

Value.Suit

Value is 1..13
Suit is 0, .25, .5, .75

Variables Used

L₁, ∟DECK

Calculator Compatibility

TI-83/84/+/SE

Download

deckofcards.zip

Creating the deck

seq(X/4,X,4,55→DECK

Shuffling the deck

rand(52→L₁
SortA(L₁,∟DECK

Accessing individual cards

∟DECK(I
Disp "VALUE:",sub("A23456789TJQK",int(Ans),1 
Disp "SUIT:",sub("SHCD",4fPart(Ans)+1, 1

The cards in the deck are stored in the form Value.Suit, where the value of the card (Ace through King) is encoded as a number 1 through 13; and the suit of the card is the fractional part, encoded as one of 0, 0.25, 0.5, or 0.75. In the above code (accessing individual cards), the convention is that 0=Spades, 0.25=Hearts, 0.5=Clubs, 0.75=Diamonds; however, you can pick any order as long as you're consistent.

Since any value from 1.00 to 13.75, that's 1/4 of an integer, is a valid card, we can generate the entire deck as 1/4 of the values {4,5, …, 54, 55}.

When shuffling the deck, we generate a random list in L₁, then use SortA( to sort ∟DECK by the values in L₁. Since the values in L₁ are random, this has the effect of sorting ∟DECK in a random order.

The main overhead of this shuffling method, however, is that generating a random list might take a long time (around a second or two). To avoid this, you can generate individual elements of L₁ randomly in a getKey loop, while waiting for a key, then use L₁ to shuffle later. Since shuffling isn't done often, by the time you need to shuffle, L₁ will most likely be fully randomized already.

Finally, accessing the cards is done using fPart( and int(. If a variable X is encoded in the same way that we encode cards, int(X) will return its value (1-13) and 4fPart(X)+1 will return its suit as a number 1-4.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/deck-of-cards


Draw Ellipse

Routine Summary

Draws an ellipse with specified coordinates.

Inputs

(A,B) - upper left corner, in pixels
(C,D) - lower right corner, in pixels

Outputs

Ellipse inscribed in the rectangle from (A,B) to (C,D)

Variables Used

A,B,C,D for input
∟X and ∟Y store a sin/cos look-up table
Plot1 to store the unit circle
Pic1 to preserve background

Calculator Compatibility

All

Author

Mikhail Lavrov (DarkerLine)

URL: http://mpl.unitedti.org/?p=13

Setup:

:cos(.1πcumSum(binomcdf(20,0→X
:sin(.1πcumSum(binomcdf(20,0→Y
:Plot1(xyLine,∟X,∟Y,(dot)
:PlotsOff

Main code:
:StorePic 1
(:ZoomSto)
:-(B+D)/abs(D-B→Xmin
:(A+C-124)/abs(C-A→Ymin
:2/abs(D-B→ΔX
:2/abs(C-A→ΔY
:PlotsOn 1
:RecallPic 1
:StorePic 1
:PlotsOff
(:ZoomRcl)
:RecallPic 1

To use the routine, add the setup code to the beginning of your program. Then, to draw an ellipse, initialize (A,B) and (C,D) to be opposite corners of an imagined rectangle, in pixel coordinates, and run the main code of the routine. The ellipse will be drawn inside this rectangle (much like the functionality of the circle tool in Paint). Unlike built-in pixel commands, this routine doesn't require the pixels to be on-screen: you can use negative coordinates, and coordinates past the 62nd row and 94th column - of course, if you do, then the off-screen part of the ellipse won't be drawn.

As for speed, the routine is far faster than the Circle( command. If you use Circle( with its undocumented fourth argument, that is a bit faster still - but doesn't allow you as much control over the shape of the ellipse as this routine does.

This routine draws an ellipse given its pixel coordinates in two overall steps:

  1. First, it calculates the window dimensions so that the unit circle (centered at the origin, with radius 1) will be stretched to the required pixel coordinates.
  2. Next, it draws the unit circle.

If the unit circle is stretched to fit in the rectangle from (A,B) to (C,D) then we know the following:

  • The vertical distance from A to C (in pixel rows) should be equivalent to the window distance 2 (from -1 to 1). This allows us to solve for ΔY.
  • The horizontal distance from B to D (in pixel columns) should also be equivalent to the window distance 2. This allows us to solve for ΔX.
  • The pixel most nearly corresponding to the midpoint between (A,B) and (C,D) should be equivalent to the point (0,0), the center of the circle. Given ΔX and ΔY, this allows us to solve for Xmin and Ymin.

The exact math isn't significant, but it gives rise to the formulas you see in the routine. Note that by using the abs( command, we ensure that the order of the two points (A,B) and (C,D) isn't important: you can switch A and C, or B and D, and still get the same circle.

The code for actually drawing the circle uses a look-up table for sine and cosine (which defines 20 points spaced around the circle). The table is calculated in the setup code, and then an xyLine plot is initialized, which will connect these 20 points when graphed. Now, to draw the unit circle, all that needs to be done is to enable the plot, using the PlotsOn command. This actually draws a 20-gon, rather than a circle, but the difference is imperceptible even on large circles.

The rest of the code is necessary to preserve the graph screen as the window changes and Plot1 is enabled and disabled (which causes the screen to be cleared), using StorePic and RecallPic. Optionally, you can also preserve the window dimensions, using ZoomSto and ZoomRcl — this is useful if your program mixes pixel and point commands.

The routine uses three fairly large variables to do its work: ∟X, ∟Y, and Pic1. ∟X and ∟Y need to be preserved from the setup code to whenever the routine is called; Pic1 is only used temporarily. It's a good idea to clean up all three by deleting them at the end of the program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/draw-ellipse


Highlighting Text

Routine Summary

Highlights text, displaying it in white on a black background.

Inputs

Str1 - text to be displayed
A - row coordinate of the text
B - column coordinate of the text
W - pixel width of the text

Outputs

None

Variables Used

Str1, A, B, C, W

Calculator Compatibility

TI-83/84/+/SE

Download

highlighttext.zip

:Text(A,B,Str1
:For(A,A,A+6
:For(C,B-1,B+W
:Pxl-Change(A,C
:End:End

First, we display the string using Text( on the graph screen. This displayed it normally, using black on white. To switch it to white on black, we need to flip the pixels from white to black and black to white — this can be done using Pxl-Change(. We chose the pixel command over the point command for two reasons: first, it is slightly faster, and second, it uses the same coordinate system as Text( — pixels (if we used Pt-Change, we'd need to convert from pixels to points to be sure of drawing in the same location).

We loop A from above to below the text, and C from just before the text to immediately after it. Note that because of the way the For( loop works — it saves the lower and upper bound before doing the loop — we can reuse the variable A. But we can't reuse B in the same way in the second For( loop, because the loop is done multiple times — it would work correctly the first time, but then B would have changed for the second.

Since Text( uses variable-width font, we need the W variable to tell us how long the string is in pixels. For uppercase letters, the width is 4 pixels; for spaces, the width is 1 pixel, and for lowercase letters, the width varies from 2 to 6 pixels.

Because Pxl-Change( must not go off the screen, check to see that the string fits on the screen entirely (with a border of 1 pixel around it) before displaying it.

Error Conditions

  • ERR:DOMAIN is thrown if the string does not fit on the screen entirely.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/highlighting-text


Key Code Retriever

Routine Summary

Retrieves the key code of any key pressed

Calculator Compatibility

TI-83/84/+/SE

:Repeat Ans
:getKey
:End
:Ans

This routine loops until a key is pressed. When a key is pressed, the key code for that specific key is displayed.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/key-code-retriever


List Frequency

Routine Summary

Returns a list of the frequency of values in another list.

Inputs

L₁ - the list you want to find the frequency of

Outputs

L₂ - the values of L₁ without repetition
L₃ - the frequencies of the values in the list L₂

Variables Used

L₁, L₂, L₃, I

Calculator Compatibility

TI-83/84/+/SE

Author

DarkerLine

URL: United TI

Download

listfrequency.zip

:{L₁(1→L₂
:{1→L₃
:For(I,2,dim(L₁
:If max(L₂=L₁(I:Then
:L₃+(L₂=L₁(I→L₂
:Else
:augment(L₂,{L₁(I→L₂
:augment(L₂,{1→L₃
:End:End

With our list of values stored in L₁, we store the first element of L₁ to L₂ to initialize it, and store a value of one to L₃ because that value has appeared once in the list (by default it is the first value and thus we know it appeared). We then begin looping in the second element to avoid an extra increment and then through all of the elements of L₁.

When determining the frequency of a value, we need to check to see if the particular element (in this case, L₁(I)) has already appeared in L₂. If it has, we increment (add one) to its respective frequency in L₂. However, if the value has never appeared in L₁, we add that value as a new element to the end of L₂ and also set its frequency to one. We repeat this until we have the frequency of all of the values in L₁ stored in L₂.

When you are done using L₁, L₂, and L₃, you should clean them up at the end of your program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/deleted:list-frequency


List Frequency Fast

Routine Summary

Returns a list of the frequency of values in another list sorted.

Inputs

L₁ - the list you want to find the frequency of

Outputs

L₂ - the values of L₁ without repetition sorted
L₃ - the frequencies of the values in the list L₂ sorted

Variables Used

L₁, L₂, L₃, θ

Calculator Compatibility

TI-83/84/+/SE

Author

Galandros

URL: United TI

Download

listfrequency2

:DelVar L₂DelVar L₃SortA L₁
:For(θ,1,dim(L₁
:L₁(θ→L₂(1+dim(L₂
:sum(L₁=Ans→L₃(dim(L₂
:θ-1+Ans→θ
:End

In the first line we initialize L₁, L₂, and L₃. We sort L₁ so like values will be adjacent.

Then we start looping by storing the first value encountered to the next element of list L₂.
In the next line we find the frequency of the value already stored in L₂ and is stored to the correspondent element in L₃. θ is increased by the frequency found minus 1 to pass to next number, but then incremented by 1 in the For loop.
We loop we reach the end of L₁.

And that's it. The output is put on L₂ and L₃ already sorted. Notice how well Ans is used for speed and size optimization.

When you are done using L₁, L₂, and L₃, you should clean them up at the end of your program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/list-frequency2


List Frequency Sorting

Routine Summary

Sorts a list based on frequency, then by value

Inputs

L₁ - A list to be sorted

Outputs

L₁ - The original list, sorted by frequency of elements

Variables Used

L₁, L₂, L₃

Calculator Compatibility

TI-83/84/+/SE/CSE/CE

Author

Trenly

SortD(L₁
DelVar L₂DelVar L₃
SetUpEditor
For(θ,1,dim(L₁
L₁(θ→L₂(1+dim(L₂
sum(L₁=Ans→L₃(dim(L₂
θ-1+Ans→θ
End
DelVar L₁
SetUpEditor
While dim(L₂
1+sum(not(cumSum(L₃=max(L₃→θ
L₃(θ)→N
For(E,1,N
L₂(θ→L₁(1+dim(L₁
End
For(E,θ+1,dim(L₂
L₂(E→L₂(E-1
L₃(E→L₃(E-1
End
dim(L₂)-1→dim(L₂
dim(L₃)-1→dim(L₃
End

This routine uses the List Frequency routine to find the frequency of each number. It then deletes, and reconstructs L₁ from the values in those lists by searching for the highest frequency, then adding it into L₁ the number of times it occurs. It then shifts the elements inside the frequency lists above the value down 1, overwriting the value which was just inserted into L₁. It then decreases the length of the frequency lists, and repeats until there are no more values to be added. This routine automatically cleans up, leaving L₂ and L₃ empty. If you wish to sort in ascending frequency, change the max( on line 12 to min(. If you wish to sort the values in ascending order instead of descending order, change the SortD( on line 1 to SortA(

Error Conditions

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/list-frequency-sorting


List to String

Routine Summary

Converts a list of numbers to a string.

Inputs

L₁ - The list you want to convert

Outputs

Str1 - The string that the text is stored to

Variables Used

L₁, A, Ans, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

listtostring.zip

Note: If you have a TI-84+ CE with OS 5.2 or higher, you can ignore this entire routine and just use the toString( command.

:"?
:For(A,1,dim(L₁
:Ans+sub("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ",1+L₁(A),1
:End
:sub(Ans,2,length(Ans)-1→Str1

With our list of values stored in L₁, we loop through each element of L₁ and store the character to our string that is at the matching position in our substring. In order to construct a string with all of the characters from L₁, we first need to create a dummy string. This is what the "? is used for.

Each time through the For( loop, we concatenate the string from before (which is still stored in the Ans variable) to the next character that is found in the list. Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable.

By the time we are done with the For( loop, all of our characters are put together in Ans. However, because we stored the dummy character as the first character at the beginning of the string, we now need to remove it, which we do by simply getting the substring from the second character to the end of the string. Finally, we store the string to a more permanent variable (in this case, Str1) for future use.

This routine allows for values from 0 to 36 in the list, since our string of characters is the ten digits and 26 uppercase letters, plus a space, and each list value must match up to one of the string positions. If you add more characters to the string, such as lowercase letters, however, you can increase the range of values in the list; if you need fewer characters you can simply remove them. This routine uses L₁, so you should clean it up at the end of your program.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/list-to-string


Marquee

Routine Summary

Scrolls a string across one line, in marquee fashion, on the home screen.

Inputs

Str1 - the text to be scrolled
A,B - the Output( coordinates for the text
N - the number of characters to display at a time

Outputs

None

Variables Used

Str1, A, B, N, Ans

Calculator Compatibility

TI-83/84/+/SE

Author

Weregoose

URL: United TI

Download

marquee.zip

:Str1
:Repeat getKey
:Output(A,B,sub(Ans,1,N
:sub(Ans,2,length(Ans)-1)+sub(Ans,1,1
:If dim(rand(4
:End

By leaving Str1 by itself on one line, we store it to Ans, which will be easier to work with. Then, the Repeat getKey loop will display the marquee until a key — any key — is pressed.

Output(A,B,sub(Ans,1,N will display N characters of Str1 at A,B. Then, the next line will rotate Str1, so that the next time we're at this point in the loop, the string shifts one character.

Finally, If dim(rand(4 is a clever way of delaying the marquee, so it doesn't scroll too fast. rand(4 generates a list of 4 random numbers, which is a slightly time-consuming process. If dim( is just a way of wrapping this list so it doesn't change Ans. Since dim(rand(4 is always 4, the If statement will always be true, so we don't have to worry about the next line being skipped. By changing 4 to a lower or higher number, you can make the marquee go faster or slower, respectively.

Error Conditions

  • ERR:INVALID DIM is thrown if the length N is longer than the number of characters in Str1.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/marquee


Matrix to String

Routine Summary

Converts a matrix to a string.

Inputs

[A] - The matrix you want to convert

Outputs

Str1 - The string that the text is stored to

Variables Used

[A], L₁, A, B, Ans, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

matrixtostring.zip

Note: If you have a TI-84+ CE with OS 5.2 or higher, you can ignore this entire routine and just use the toString( command.

:dim([A]→L₁:"?
:For(A,1,L₁(1
:For(B,1,L₁(2
:Ans+sub("ABCDEFGHIJKLMNOPQRSTUVWXYZ",[A](A,B),1
:End:End
:sub(Ans,2,length(Ans)-1→Str1

With our values stored in [A], we get the dimensions (row x column) of the matrix, which are stored in a list. We then loop through each row and column, and store the character at the respective element to our string that is at the matching position in our substring. In order to construct a string with all of the characters from [A], we first need to create a dummy string. This is what the "? is used for.

Each time through the For( loops, we concatenate the string from before (which is still stored in the Ans variable) to the next character that is found in the matrix. Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable.

By the time we are done with the For( loops, all of our characters are put together in Ans. However, because we stored the dummy character as the first character at the beginning of the string, we now need to remove it, which we do by simply getting the substring from the second character to the end of the string. Finally, we store the string to a more permanent variable (in this case, Str1) for future use.

This routine only allows for values from 1 to 26 in the matrix, since our string of characters is the uppercase alphabet, and each matrix value must match up to one of the string positions. If you add more characters to the string, however, you can increase the range of values in the matrix. This routine uses [A] and L₁, so you should clean them up at the end of your program.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/matrix-to-string


Modular Arithmetic Solver

Routine Summary

Finds the remainder of a division between two numbers.

Inputs

A,M

Variables Used

A,M

Calculator Compatibility

TI-83/84/+/SE

:A-Mint(A/M

This program takes modular equations of the form X ≡ A (mod M) and solves them for the common residue, which is equal to the remainder after A has been divided by M. Among other things, it can be useful for finding the day of the week (with Sunday–Saturday matching up with 0–6) after M number of days has passed, or the time on a clock after a number of hours has passed.

For example, if we were on a Saturday (which is day 6, given that Sunday is day 0), and we wanted to figure out what it will be in 18 days, we would store 6+18→A, then 7→M as the appropriate number of days in a week, and finally we would calculate MfPart(A/M to get 3, which translates to a Wednesday.

This simpler version can be used if A is guaranteed to be positive:

:MfPart(A/M

It may fail due to rounding precision errors.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/modular-arithmetic-solver


Newtons Method

Routine Summary

Newton's Method - calculates the value of an equation

Inputs

Variant 1: Str1, A
Variant 2: Str1, Str2

Str1 and Str2 - The equation(s) are stored to the string variables.
Y1 and Y2 - The equation(s) are stored to the Y-variables from the string variables, then used for operations.
A - To store the seed value, and then the final value of the equation.

Outputs

A - The answer is stored to A

Variables Used

A, Y1, Y2

Calculator Compatibility

TI-83/84/+/SE/CSE/CE

Authors

Variant 1:Myles_Zadok
Variant 2: Xeda Elnara

Download

newton.zip

Newton's Method is a routine for math that calculates the value of the zeroes of an equation, or the intersection point of two equations.

Variant 1

:Input "Y1=",Str1
:Str1→Y1
:Input "SEED VALUE=",A
:For(I,1,10)
:Tangent(Y1,A)
:A-((Y1(A))/(nDeriv(Y1,X,A)))→A
:End
:Disp "APPROX. ROOT IS ",A

The program asks the user for an equation and the seed value. The seed value is the point from which the calculator approximates the zero of the function, so the seed value needs to be close to the desired zero. The calculator then begins the For( loop, which is run 10 times, each time getting a closer approximation of the zero. The loop draws a tangent line and runs the formula for the zero of the function. The answer, depending on the seed value, should be really close to the zero of the function.

In case you're wondering, you can remove the Tangent( command altogether and make the program run faster. However, you will have no clue as to whether you chose a good seed value or not. The Tangent( command slows down the program, but it lets you see if your chosen seed value will be accurate or not.

Variant 2

Variant 2
:Input "Y1 ",Str1
:Str1→Y1
:Input "Y2 ",Str2
:Str2→Y2
:0→I
:Repeat I=10 or K<20
:I+1→I
:0→K
:10rand→A
:Ans+1
:While K<20 and E-10<abs(A-Ans
:Ans→A
:K+1→K
:A-(Y1(A)-Y2(A))/nDeriv((Y1-Y2),X,A
:End
:End
:Disp Ans

The program asks for two equations and runs Repeat and While loops followed by the formula for the X-coordinate of the intersection of the two equations. The answer should be the value of the X-coordinate of the intersection.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/newtons-method


Number Concatenation

Routine Summary

Concatenates two whole numbers together.

Inputs

M - the first number
N - the second number

Outputs

O - the concatenated number

Variables Used

M, N, O

Calculator Compatibility

TI-83/84/+/SE

Author

DarkerLine

URL: United TI

Download

numberconcatenation.zip

:N+M10^(1+int(log(N→O

With our two numbers stored in M and N respectively, we add the first number to the second number by raising it to the 10th power, with the exponent being how many digits are in the number. We then store this result to a new variable for later use.

We can figure out how many digits are in a number by using the 1+int(log( trick. This trick works with any positive whole numbers, and if you add abs( after log(, it will also work with negative numbers. Unfortunately, it does not work with decimals.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/number-concatenation


Number Factorization

Routine Summary

Returns the factors of a number.

Inputs

X - the number you want to factor

Outputs

L₁ - the factors of the number

Variables Used

X, L₁, Ans

Calculator Compatibility

TI-83/84/+/SE

Author

Weregoose

URL: United TI

Download

numberfactors.zip

:{1→L₁
:Repeat Ans=1
:2:While fPart(X/Ans
:Ans+1
:End
:Ans→L₁(1+dim(L₁
:X/Ans→X
:End

Number factorization breaks a number up into its factors - smaller numbers that that are multiplied together to create the number. For example, the number 100 can be broken up into the factors 2*2*5*5. It can also be represented as 10*10, or 5*20, but for the sake of completeness, this routine finds prime factors — which can't be broken down themselves (2*2*5*5 is such a factorization, since there's no way to factor 2 or 5, but 5*20 isn't, since 20 can still be factored).

In order to start collecting the factors of the number, we create a list with the initial factor of 1 (because 1 is a factor for every number). We then begin looping through numbers, starting with 2, to find the next factor. The way we determine if we have a factor is by dividing the original number by the respective number we are at, and checking if there is a remainder.

If there is a remainder, we know that the number is not a factor, and we then increment it and continue looping. If there is no remainder, however, we have found a factor, and thus the loop will end. We then add that factor as the next element in our factors list, and divide the original number by that factor and set the result as the new number. This gets repeated over and over again until we have our list of factors.

The factors list should be generated pretty quickly, but it all depends on the original value that you chose for X; a smaller value will be faster, and likewise a larger value will be slower. In addition, if you try starting with a negative number or a number with a decimal part, then the program will not work correctly.

When you are done using L₁, you should clean it up at the end of your program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/factorization


Number Subset

Routine Summary

Returns a subset of a number.

Inputs

A - the number to get the subset from
B - the starting position of the subset
C - the length of the subset

Outputs

Ans - the subset of the number

Variables Used

A, B, C, Ans

Calculator Compatibility

TI-83/84/+/SE

Author

Weregoose

URL: United TI

Download

numbersubset.zip

:10^(2-B+int(log(A
:int((A-int(A/Ans)Ans)/Ans10^(C

With our number stored in A, and the staring position and length of the subset stored in B and C respectively, we get the subset of the number by first subtracting the number divided by 10 to the power of 2-B+int(log(A (which is used to get how many digits are in the number), and then dividing that result by multiplying 10 to the power of 2-B+int(log(A and 10 to the power of C (which is the length of the subset).

A simple example should help you understand this routine. Say you input the number 123, with a starting position of 2 and a length of 2, it will return a result of 23. You can also use negative and decimal numbers with the routine, and it will still work correctly: a number of 13579.02468 with a starting position of 4 and length 4 will return 7902.

This routine is comparable to the sub( command that works with strings.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/number-subset


Number to String

Routine Summary

Converts a real number to a string.

Inputs

N - the number you want to convert

Outputs

Str1 - the number N in string form

Variables Used

L₁, L₂, Y₁, Str1, N

Calculator Compatibility

TI-83/84/+/SE

Download

numbertostring.zip

Note: If you have a TI-84+ CE with OS 5.2 or higher, you can ignore this entire routine and just use the toString( command.

:{0,1→L₁
:NAns→L₂
:LinReg(ax+b) Y₁
:Equ►String(Y₁,Str1
:sub(Str1,1,length(Str1)-3→Str1

This code works because it creates two points with a known best fit line: the best fit line through (0,0) and (1,N) is y=Nx+0. LinReg(ax+b) calculates this best fit line, and stores its equation to Y₁.

Then, we use Equ►String( to store this equation to Str1, which now contains "NX+0" with N replaced by the numerical value of N. After that, the sub( command get rids of the "X+0" at the end, leaving only the string representation of N.

This routine uses L₁, L₂, and Y₁, so you should clean up those variables at the end of your program. If you're working with the graph screen in function mode, storing to Y₁ can be a problem since it will draw an unwanted line through your graphics. Use r₁ instead but make sure the calculator isn't in polar mode.

Note: This only works for real numbers. With complex numbers, such as imaginary numbers, you can use this code at the end of the first to get the same effect with i in it. This routine will also only work for N<10^50. To convert larger N, see the alternate below.

:Str1+"i→Str1

Alternate Routine

The following routine will perform the same function for converting N to a string as shown above. This routine, however, allows N to be as large as the TI-84+ overflow limit (10^100) by utilizing Med-Med regression.

:{0,.5,1→L₁
:NAns→L₂
:Med-Med Y₁
:Equ►String(Y₁,Str1
:sub(Str1,1,length(Str1)-3→Str1

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/number-to-string


Pad a String

Routine Summary

Pad a string with spaces on the left and right.

Inputs

Ans - The string you want to pad
N - How many spaces you want

Outputs

Str1 - The padded string

Variables Used

X, N, Ans, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

padstring.zip

:For(X,1,N
:" "+Ans+" 
:End
:Ans→Str1

With our string stored in Ans, we concatenate (add) a space to the beginning and end of the string. At the same time, the new string is stored to Ans, which is what we use next time through the For( loop. The loop gets repeated over and over again until we have added however many spaces we wanted. If you only want spaces on one side of the string, edit the second line accordingly.

Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable.

We store the string to a more permanent variable (in this case, Str1) for future use. When you are done using Str1, you should clean it up at the end of your program.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/pad-a-string


Repeat a String

Routine Summary

Repeats a string however many times you want.

Inputs

Ans - The string you want to repeat
2N - How many times you want the string repeated

Outputs

Str1 - The repeated string

Variables Used

X, N, Ans, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

repeatstring.zip

:For(X,1,N
:Ans+Ans→Str1
:End

With our string stored in Ans, we concatenate (add) another copy to the end of the string, and store the new string to Str1. At the same time, the new string is also stored to Ans, which is what we use next time through the loop. The loop gets repeated over and over again until we have added however many copies we wanted. If you want to add more than one copy of the string each time through the loop, edit the second line accordingly.

Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable. In addition, by storing the string to Str1 inside the loop, we avoid having to add an additional storage to the routine.

We store the string to a more permanent variable (in this case, Str1) for future use. When you are done using Str1, you should clean it up at the end of your program.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/deleted:repeat-a-string


Reverse a String

Routine Summary

Reverses the characters in a string.

Inputs

Str1 - The string you want to reverse

Outputs

Str1 - The reversed string

Variables Used

Str1, I, Ans

Calculator Compatibility

TI-83/84/+/SE

Download

reversestring.zip

:Str1
:For(I,1,length(Ans)-1
:sub(Ans,2I,1)+Ans
:End
:sub(Ans,1,I→Str1

With our string stored in Str1 and Ans, we loop through each character, starting from the beginning to the end, and add it to the beginning of the string, building the reversed string up at the beginning as we go:

12345    (original string - the first character is the first reversed character)
212345   (add then second character before the first, reversing the string)
3212345  (continue adding characters in reverse)
543212345 (this is what the end result looks like)

Since adding to the beginning of the string alters the indices, we must take that into account — this is where the 2I in the formula comes from. It adds the 2nd character the first time, the 4th character (which was originally the 3rd) next, the 6th character (originally the 4th) after that, and so on.

Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable.

By the time we are done with the For( loop, all of our characters are put together in Ans in reverse order, before the original string. To finish, we take the first (reversed) half as a substring and store it back in Str1 for further use. We can use I for this purpose because it looped from 1 to length(Str1)-1, so its value will be length(Str1) when exiting.

If you want to preserve the original string, store it to a different string variable in the first line of the code.

When you are done using Str1, you should clean it up at the end of your program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/reverse-a-string


Run-Length Encoding (RLE) Compression

Routine Summary

Compresses a list of numbers using RLE compression.

Inputs

L₁ - The list of numbers you want to compress

Outputs

L₁ - The list of compressed numbers

Variables Used

L₁, I, J

Calculator Compatibility

TI-83/84/+/SE

Download

rlecompress.zip

:1→J
:For(I,2,dim(L₁
:If L₁(I)=L₁(J:Then
:.002+L₁(J→L₁(J
:Else
:If L₁(I)=int(L₁(J:Then
:.001+L₁(J→L₁(J
:Else
:J+1→J
:L₁(I→L₁(J
:End:End:End
:J→dim(L₁

Run-length encoding (RLE) is a very easy compression algorithm that you can use for compressing a list of numbers. The way it works is that you remove all of the consecutive repeated numbers from the list, and modify the first instance of the numbers with how many repeated numbers there were.

For example, say you have a list of numbers 1,2,2,3,3,3,4. You start with the 1, and since there is only one 1, it wouldn't be modified. There are two 2's, however, so you would remove the second two, and add a decimal part (using fPart() of how many 2's there were (in this case, just two, which we represent as .002). You would do this for the rest of the list, and the final list would be 1,2.002,3.003,4.

To save memory (which is of course the reason we're compressing) we will store the result to L₁, the same list the uncompressed data is in. Throughout the loop, J is the index of the last element of the compressed part of the list, and I is the index in the uncompressed part. We don't have to worry about the indices colliding, since I is always bigger than J.

We loop over the list with I, and check if the current element has the same value as the last element of the compressed list. If it is, then it's the beginning of a run, so we add .002 to that last element.

If it isn't there's another possibility — the last element could represent an existing run of the same element. We check for this with the code If L₁(I)=int(L₁(J)). If this turns out to be the case, we add .001 to increase the length of the run. Otherwise, the element really is different, and we increase J and add a new element.

At the end, we store J to the size of L₁. This gets rid of all the unnecessary data, leaving us only with the compressed portion of the list.

Note that we never store anything to L₁ itself, only to its elements. This is a useful technique to avoid using too much memory while the program is running: if we stored to L₁, a copy of the list would be stored to Ans, which could easily give a ERR:MEMORY if the list is too large. As the program is now, the only additional memory used is contained in three real variables (I, J, and Ans).

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/rle-compress


Run-Length Encoding (RLE) Decompression

Routine Summary

Decompresses a run length-encoded list.

Inputs

L₁ - The compressed list

Outputs

L₁ - The decompressed list

Variables Used

L₁, I, J

Calculator Compatibility

TI-83/84/+/SE

Download

rledecompress.zip

:dim(L₁→J
:sum(E3fPart(L₁)+not(fPart(L₁→dim(L₁
:For(I,Ans,1,-1
:int(L₁(J→L₁(I
:If .001<fPart(L₁(J:Then
:L₁(J)-.001→L₁(J
:Else
:J-1→J
:End:End

Run-length encoding (RLE) is a very easy compression algorithm that you can use for compressing a list of numbers. The way it works is that you remove all of the consecutive repeated numbers from the list, and modify the first instance of the numbers with how many repeated numbers there were.

For example, say you have a list of numbers 1,2,2,3,3,3,4. You start with the 1, and since there is only one 1, it wouldn't be modified. There are two 2's, however, so you would remove the second two, and add a decimal part (using fPart() of how many 2's there were (in this case, just two, which we represent as .002). You would do this for the rest of the list, and the final list would be 1,2.002,3.003,4.

This routine could loosely be described as the RLE compression routine, but backwards. We start by calculating the length of the decompressed list. This is the sum of the length of the runs — E3fPart(L₁) — plus the number of elements with no runs — not(fPart(L₁)). Here E represents the scientific E.

Then, the decompression begins. The routine keeps the following loop invariants (things that stay true after each iteration of the loop):

  • Every element after the Ith element is the correct decompressed element in that spot.
  • The portion of the list up to and including the Jth element is the compressed version of the list elements that will be 1 through I.

We "unpack" one element from the end of the compressed portion: int(L₁(J→L₁(I. Then we test if this compressed portion is a run that still contains more elements. If it is, we subtract .001, reducing the number of elements in the run by 1. If it's not, we decrease J by 1 to move on to the previous compressed element. As you can see, the conditions listed above are still true.

Once the loop ends, the first condition of the ones above ensures that all elements have been correctly decompressed.

Note that we never store anything to L₁ itself, only to its elements. This is done to avoid using any more memory than necessary: if we stored to L₁, a copy of the list would get temporarily stored to Ans, and we would be using twice the memory we need. This way, the routine will work even for large lists. As a bonus, the only time we change the size of the list is the very beginning. So if the decompressed list wouldn't fit in memory, the routine crashes immediately and keeps the list intact.

Error Conditions

  • ERR:MEMORY is thrown if there is not enough space to store the decompressed list.
  • ERR:INVALID DIM is thrown if the decompressed list would be longer than 999 elements.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/rle-decompress


Scramble a String
scramble_routine.gif

Routine Summary

Scrambles a string

Inputs

Str1 - The string you want to scramble

Outputs

Ans - The scrambled string

Variables Used

Ans, Str1, L, N, L₁, L₂

Calculator Compatibility

TI-83/84/+/SE

Authors

seb83, Edward H, Timothy Foster

Download

scramble_prgm.zip

This routine takes a string stored in Str1 and scramble it. The results is contained in Ans. For example, "ABCDE12345" could be scrambled to "B34AC1DE25".

:rand(length(Str1→L₁
:cumSum(1 or Ans→L₂
:SortA(L₁,L₂
:sub(Str1,L₂(1),1
:For(N,2,length(Str1
:Ans+sub(Str1,L₂(N),1
:End

With your string stored in Str1, it creates L₁={1,2,3,4,…,length(Str1)}. After that, L₂ is created randomly to sort L₁ in function of L₂. L₁ now could look like {5,3,4,1,2} if you entered a 5 character string. In the For( loop, it takes one by one the character of Str1 accordingly to L₁ to store it to Ans. Your scrambled string is now in Ans.

For the TI-84+ and higher with a MathPrint or color OS, use this code instead:

:randIntNoRep(1,length(Str1→L₁
:sub(Str1,Ans(1),1
:For(N,2,length(Str1
:Ans+sub(Str1,L₁(N),1
:End

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/scramble-a-string


Shading Circles

Routine Summary

Shades in a circle.

Inputs

R - the radius of the circle
A - the X coordinate of the circle's center
B - the Y coordinate of the circle's center

Outputs

None

Variables Used

N, R, A, B

Calculator Compatibility

TI-83/84/+/SE

Author

Jutt

URL: United TI

Download

shadecircles.zip

:For(N,0,R,ΔX
:√(R²-N²
:Line(A+N,B-Ans,A+N,B+Ans
:Line(A-N,B-Ans,A-N,B+Ans
:End

Although it is possible to shade in a circle using the Shade( command (i.e., Shade(-√(R²-(X-A)²)+B,√(R²-(X-A)²)+B)), that is actually quite impractical in a real program because of its slow speed. Fortunately, you can improve upon that by using your own routine.

When graphing a circle, there are a few main things you need to know: the radius and the (X,Y) coordinates of the center. In our routine, the R variable is the radius, the A variable is the circle's X coordinate and the B variable is the circle's Y coordinate.

Rather than displaying the circle as one big circle, we are going to display it line by line using a For( loop, starting from the center. The √(R²-N² formula is based on the circle formula R2=(X–H)2+(Y–K)2, with the formula rearranged to get the respective part of the circle.

The circle should display pretty quickly, but it all depends on the values that you chose for the variables; smaller values will be faster, and likewise larger values will be slower. In addition, the circle may not display correctly if you don't have the right graph settings, so you should set your calculator to a friendly graphing window.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/shading-circles


String to List

Routine Summary

Converts a string to a list of numbers.

Inputs

Str1 - The string you want to convert

Outputs

L₁ - The list that the numbers are stored to

Variables Used

L₁, A, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

stringtolist.zip

:1+seq(inString("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ",sub(Str1,A,1)),A,1,length(Str1→L₁

With our characters stored in Str1, we loop through each character and store its position in our reference string (the uppercase alphabet) to the respective element of L₁.

This routine only allows for values from 1 to 26 in the list, since our string of characters is the uppercase alphabet, and each list value must match up to one of the string positions. If you add more characters to the string, however, you can increase the range of values in the list. This routine uses Str1, so you should clean it up at the end of your program.

Advanced Routine

Since a list element can store up to 14 digits, you can use int(, fPart(, and exponents to compress an additional 7 letters per element (2 digits for each letter), thus increasing your total number of characters to 6993.

" ABCDEFGHIJKLMNOPQRSTUVWXYZ->Str0
DelVar L1
For(A,0,dim(L1
0
For(B,1,min(7,length(Str1)-7A
Ans+.1^(2B)inString(Str0,sub(Str1,B+7A,1
End
Ans->L1(A+1
End
"

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/string-to-list


Strip a String

Routine Summary

Strip a string of its spaces on the left and right.

Inputs

Ans - The string you want to strip

Outputs

Str1 - The stripped string

Variables Used

Ans, Str1

Calculator Compatibility

TI-83/84/+/SE

Download

stripstring.zip

:While " "=sub(Ans,1,1) or " "=sub(Ans,length(Ans),1
:sub(Ans,1+(" "=sub(Ans,1,1)),length(Ans)-1→Str1
:End

With our string stored in Ans, we check to see if there is a space at the beginning or end of the string. If there is a space, then we remove it by storing the substring of the string that doesn't include the first character (for a space at the beginning) or the last character (for a space at the ending), and store the new string to Str1.

At the same time, the new string is stored to Ans, which is what we use next time through the While loop. The loop gets repeated over and over again until we have stripped all of the spaces from the beginning and end of the string. If you only want to remove spaces on one side of the string, edit the first and second lines accordingly.

Using Ans allows us to not have to use another string variable, since Ans can act like a string and it gets updated accordingly, and Ans is also faster than a string variable. In addition, by storing the string to Str1 inside the loop, we avoid having to add an additional storage to the routine.

We store the string to a more permanent variable (in this case, Str1) for future use. When you are done using Str1, you should clean it up at the end of your program.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/strip-a-string


Sum of Digits

Routine Summary

Returns the sum of digits of a number.

Inputs

X - the number you want

Outputs

Ans - the sum of X's digits

Variables Used

X, Ans

Calculator Compatibility

TI-83/84/+/SE

Author

DarkerLine

URL: United TI

:sum(int(10fPart(Xseq(10^(-I-1),I,0,log(X

With our number stored in X, we loop through each of the digits of the number starting from the right using the seq( command. We get the respective digit by raising the number to the respective power of 10 and then multiplying the result by 10. The digits are returned separately in a list, and then we take the sum of them using the sum( command.

For example, if the number is 1234, we get a list of {1,2,3,4}, which then returns a sum of 10. You should note, though, that this routine only works with positive and negative whole numbers, and will return incorrect results if you try to use a decimal number. You could fix this problem by using the code below instead:

:abs(E13(X/10^(int(log(abs(X+not(X→X

Here, we obtain the appropriate power of ten by which to divide the number so as to leave only one digit to the left of the decimal point. Because a real variable may contain only 14 digits, the answer is multiplied by 10^13 to guarantee the removal of any fractional part. From taking the absolute value of this new result, our number can be safely entered into the routine above.

Note: It should be understood that this routine is only capable of adding the first 14 digits of a number. An input of π, for instance, would return 69 even though the sum of all digits of π is infinite.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/sum-of-digits


Sum of Matrix Elements

Routine Summary

Returns the sum of the elements of a matrix.

Inputs

[A] - the matrix whose elements you want to sum

Outputs

Ans - the sum of the matrix elements

Variables Used

[A], L₁, Ans

Calculator Compatibility

TI-83/84/+/SE

Author

zada

URL: United TI

Download

sumofmatrix.zip

:dim([A]
:Matr►list(cumSum([A])T,Ans(1),L₁
:sum(L₁

The cumSum( command gets the cumulative sum of each column in the matrix, adding the value of the previous element to the next element, and repeating this for each consecutive element in the column. When the cumSum( command is finished, the last element in each column will contain the sum of that column. Taking the T (transpose) of the resulting matrix switches columns and rows.

Then, using the Matr►list( command, the last column of this result is stored to L₁. This column was originally the last row of cumSum('s output, so it contains all the column sums. Finally, by calculating the sum of that list, we get the total of the matrix elements. L₁ is no longer necessary, and can be deleted.

If you want to use the sum for future use, you can store it to a more permanent variable, such as A or X. When you are done using [A], you should clean it up at the end of your program.

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/sum-of-matrix


Typewriter Routine

Routine Summary

Makes text appear letter by letter

Inputs

Str1 - Text to be displayed.
A,B - Row and colum to display text.

Variables Used

A, B, T, Str1

Calculator Compatibility

All TI calculators

:For(T,1,length(Str1
:Text(A,B,sub(Str1,1,T
:rand(5
:End

We use a For( loop over the length of the string to go through the string letter by letter. In order to make the spacing come out right, instead of figuring out the right coordinate to display each character at, we display the first T characters of the string starting from the beginning. The rand(5) provides a split-second delay to achieve the typewriter effect.

For multiple lines with the typewriter effect, you can combine this routine with the one to wordwrap text.

Error Conditions

  • ERR:DOMAIN is thrown if the string doesn't fit entirely on the screen.

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/typewriter


Wordwrapping Text on the Graphscreen

Routine Summary

Displays text on several lines on the graph screen.

Inputs

Str1 - text to display
A - starting row
B - starting column

Outputs

None

Variables Used

Str1, A, B, C, Ans

Calculator Compatibility

TI-83/84/+/SE

Download

wordwrap.zip

:1→C
:For(A,A,57,6
:inString(Str1,"/",Ans
:Text(A,B,sub(Str1,C,Ans-C
:If Ans=length(Str1:57→A
:Ans+1→C
:End

This routine displays a string on the graph screen, with line breaks after every slash "/" character. The routine requires there to be a slash at the end of the string (so, a sample string would be "THIS TEXT IS TOO LONG TO/DISPLAY ON ONE LINE/").

The row and column (A and B) inputs determine the upper and left boundaries of the text. You determine the right boundary by where you put the slash characters. The lower boundary is 57, hardcoded into the routine (this is the lowest that text can be displayed), but you could change this if you wanted a different boundary.

The variable C is used for an index inside Str1, that tells us which character we're currently on. We're starting at the beginning of the string, so we store 1 to C.

The For( loop will increment A by 6 each time we display a line (small font characters are 6 pixels tall). We start at the current value of A, and end at 57 because beyond that, Text( will throw a domain error.

Now, we search for the next slash "/" character using the inString( command. Then, using Text(, we display the line between C and the "/", not including the slash itself. Ans+1→C will move the C index to the next character after the slash.

The line If Ans=length(Str1:57→A will end the loop early as soon as we reach the end of the string. This command can modify Ans, which would be bad, but it only does so when we're ready to exit anyway — at that point, we won't be needing Ans anymore.

Error Conditions

  • ERR:INVALID DIM is thrown if Str1 is improperly formatted (check for the backslash at the end).
  • ERR:DOMAIN is thrown if text goes off the screen. This shouldn't happen unless B is very close to the right edge, if A or B are negative, or if the calculator is in Horiz mode (in which case, replace 57 with 25).

Related Routines

For the most up-to-date version of this routine, see http://tibasicdev.wikidot.com/wordwrap-text

page revision: 0, last edited: 31 Oct 2008 21:30

Unless stated otherwise Content of this page is licensed under Creative Commons Attribution-Noncommercial 2.5 License.