I have a bad habit of not backing up my programs, but it doesn't make me too mad because the types of programs I write on a calculator nowadays aren't usually worthy of making public anyway. It's been a surprisingly long time since I've accidentally datawiped my 83 PCEEP, so I decided I might as well post the more completed programs here for fun, before they're all lost to time. So here you go: here's every TI-BASIC program currently on my calculator that I've written.

prgmULAMSPRL

This little program, in conjunction with a primality test I made, fills your graphscreen with an Ulam spiral until it dimension errors. It's one of the cooler little graphscreen entertainment programs I've made.

prgmISPRIME

This program is a simple primality test that takes an integer in Ans and returns either a 0 or 1 in Ans depending on primality. I used a custom list in this program instead of using any letter variables because I quickly remembered that TI-BASIC does not support locals! Unless another program happens to use ʟIP, this program won't mess with any of your other data.

prgmTRI

Yet another neat graphscreen entertainment program, this program uses a chaos game to produce a Sierpinski triangle. I forgot what exactly this method is called, but it's a cool demonstration of how chaotic systems can still be limited. Basically, every iteration, a 3 sided die is rolled, each number corresponding to a vertex of a triangle. A new dot is drawn in the midpoint between the last dot drawn and the chosen vertex, and then the program iterates again. Keep in mind that this program assumes that your graphscreen background is not white, as it draws white pixels.

prgmTRIARBTR

After I made the above program, I immediately wondered whether the fractal pattern that it produced using three vertices would extend to different regular polygons, so I made a second program that runs the same chaos game, except with an arbitrary number of vertices. I haven't checked to see if this is true, but it seems like a fractal structure is produced when running this game on any shape with an odd number of vertices, and never on a shape with an even number of vertices, though it becomes exponentially more difficult to tell on the small CE graphscreen, as the center area becomes very small very quickly. Make sure to select "0" when it asks if you want to use custom vertices, as I never coded that part of the program in.

prgmSUPERGAA

It seems like the theme of these programs is neat graphscreen demos. This program raytraces an infinite checkerboard floor pattern that extends to the horizon. By using LTGRAY, MEDGRAY, and GRAY in addition to WHITE and DARKGRAY, this program anti-aliases the whole scene by super-sampling by a factor of 2. Even on a rev M CE, this program takes quite a long time to produce a full scene, so I'd run it, set it down, and go make dinner or something. I made a non-AA version of this program, but it's not nearly as cool and has already been done plenty of times.

prgmRNGTEST

This is an interesting little program that I wrote some time ago, and it took me a while today to decipher exactly what it was meant to do. Essentially, this program tests randIntNoRep(0,9 over and over with a different initial seed for rand, keeping track of which seeds produce random lists closest to {0,1,2,3,4,5,6,7,8,9}. It outputs the random list and the seed that generated it each time it produces a list more accurate than the current most accurately produced list. I don't believe this program ever created a perfect list, and I ran it for probably an hour. I believe I wrote this for golfing purposes, where having a perfect 0-9 list would be very advantageous. You can easily search for different lists by altering the list in the sum( command.

prgmRIEMANN

This program is a fairly sophisticated definite integral approximation program, in that it returns the left, right, trapezoidal, and midpoint Riemann sums of an integral with an arbitrary number of divisions, as well as a Simpson's rule approximation and a column that shows each approximations' deviation from the exact answer, all rounded to a specified number of digits. This program was written to streamline an extremely long and boring calculus assignment.

prgmREVPOL

Finally, something fun! This program simulates a calculator operating using reverse Polish notation. It lacks a fully realized feature set, but it works perfectly fine for addition, subtraction, multiplication, division, exponents, negatives, and floats.

prgmGUESSNUM

Honestly, what's a graphing calculator without good ol' guessnum? This program is ENHANCED guessnum and supports highscores! (I wouldn't be surprised if I have written this program a hundred times.)

prgmFIND

This program is a little game that fills your screen with a grid of one character, all except one slightly different character. The goal is to pass all 6 levels as quickly as possible. There is no cursor, you're just supposed to press enter when you've found the odd one out. Honor system, folks.

prgmBOUNCE

This program was influenced by one of the cool demo programs in the SUPERHOT pseudo-filesystem. The screen is covered in a collection of angled mirrors denoted by slash and backslash, with dots coming onscreen from the left. Each time a dot hits a mirror, it is reflected by the mirror while also turning the mirror 90 degrees, so the next dot that hits that mirror goes in the opposite direction. The program runs for some time but eventually has a Dim error that I haven't had the time to weed out.

prgmNEURAL, prgmNEURALNW, prgmNEURALPL, prgmTICTAC

Finally, I've still managed to avoid deleting these enigmas of programs. I wrote all four on a long coast-to-coast flight a year or so back in an attempt to create a functional artificial intelligence via neural network functioning on my CE. This was created using my very primitive knowledge of neural networks and machine learning, so I'm not sure it ever produced any results. In theory, I think it was supposed to, but perhaps I just didn't run it for long enough. It's supposed to train a neural net how to play Tic Tac Toe.

From what I understand by looking at the code, it seems like prgmNEURALNW intializes the neural net to have 20 neurons in 4 rows, with [A] [B] and [C] used for weights between the rows. It also creates ʟSCR to save (I believe) the scores for each of 8 variations in a generation, and ʟSTAT to save highscores.

prgmNEURAL is certainly the outermost program of the set, as it contains code to randomly alter the weights between neurons.

prgmNEURALPL is called during prgmTICTAC and I believe that the program means "Neural Play" meaning it plays a move as the neural net in the ongoing game of tic tac toe. It passes in ʟJ, which contains each of the 9 squares in the game, and returns ʟS2, containing X and Y coordinates of where the net has chosen to play.

prgmTICTAC officiates each individual game of tic tac toe, and seems to log some calculation of the net's fitness that round into ʟSCR.

I'm very impressed that you actually scrolled through all of that.

prgmULAMSPRL

This little program, in conjunction with a primality test I made, fills your graphscreen with an Ulam spiral until it dimension errors. It's one of the cooler little graphscreen entertainment programs I've made.

**Code:**```
ClrDraw
```

AxesOff

GridOff

BackgroundOff

"265*165

"132 82

132→V

82→W

1→N

1→J

Repeat 0

For(S,1,1,2

For(I,1,J

V+S→V

N+1→N

prgmISPRIME

If Ans

Pxl-On(W,V,BLACK

End

For(I,1,J

W-S→W

N+1→N

prgmISPRIME

If Ans

Pxl-On(W,V,BLACK

End

J+1→J

End

End

prgmISPRIME

This program is a simple primality test that takes an integer in Ans and returns either a 0 or 1 in Ans depending on primality. I used a custom list in this program instead of using any letter variables because I quickly remembered that TI-BASIC does not support locals! Unless another program happens to use ʟIP, this program won't mess with any of your other data.

**Code:**```
Ans→⌊IP(1)
```

If ⌊IP(1)≤3

Then:1:Return:End

If not(remainder(⌊IP(1),2) and remainder(⌊IP(1),3

Then:0:Return:End

5→⌊IP(2)

While ⌊IP(2)²≤⌊IP(1)

If not(remainder(⌊IP(1),⌊IP(2)) and remainder(⌊IP(1),⌊IP(2)+2

Then:0:Return:End

⌊IP(2)+6→⌊IP(2)

End

1

prgmTRI

Yet another neat graphscreen entertainment program, this program uses a chaos game to produce a Sierpinski triangle. I forgot what exactly this method is called, but it's a cool demonstration of how chaotic systems can still be limited. Basically, every iteration, a 3 sided die is rolled, each number corresponding to a vertex of a triangle. A new dot is drawn in the midpoint between the last dot drawn and the chosen vertex, and then the program iterates again. Keep in mind that this program assumes that your graphscreen background is not white, as it draws white pixels.

**Code:**```
ZStandard
```

ZSquare

AxesOff

GridOff

10→Y

0→X

While 1

X→V

Y→W

randInt(0,2

If not(Ans

Then

X/2→X

(10+Y)/2→Y

End

If Ans=1

Then

(11.547+X)/2→X

(10+Y)/2→Y

End

If Ans=2

Then

(11.54700538+X)/2→X

(10+Y)/2→Y

End

Pt-On(X,Y,4,WHITE

"Line(X,Y,V,W,1,WHITE,1

End

prgmTRIARBTR

After I made the above program, I immediately wondered whether the fractal pattern that it produced using three vertices would extend to different regular polygons, so I made a second program that runs the same chaos game, except with an arbitrary number of vertices. I haven't checked to see if this is true, but it seems like a fractal structure is produced when running this game on any shape with an odd number of vertices, and never on a shape with an even number of vertices, though it becomes exponentially more difficult to tell on the small CE graphscreen, as the center area becomes very small very quickly. Make sure to select "0" when it asks if you want to use custom vertices, as I never coded that part of the program in.

**Code:**```
ZStandard
```

ZSquare

AxesOff

GridOff

Degree

Input "Custom Vertices? ",A

If A

Then

Else

Input "Polygon Num: ",N

N→dim(L₁

N→dim(L₂

If fPart(N/2)=0

Then

360/(2N)→C

Else

0→C

End

0→B

For(A,0+C,360-360/N+C,360/N

B+1→B

10sin(A→L₁(B

10cos(A→L₂(B

End

End

For(A,1,N

If A=N

Then

Line(L₁(N),L₂(N),L₁(1),L₂(1),1,DARKGRAY,1

Else

Line(L₁(A),L₂(A),L₁(A+1),L₂(A+1),1,DARKGRAY,1

End

End

L₁(1→X

L₂(1→Y

While 1

X→V

Y→W

randInt(1,N→A

(L₁(A)+X)/2→X

(L₂(A)+Y)/2→Y

Pt-On(X,Y,4,WHITE

"Line(X,Y,V,W,1,WHITE,1

End

prgmSUPERGAA

It seems like the theme of these programs is neat graphscreen demos. This program raytraces an infinite checkerboard floor pattern that extends to the horizon. By using LTGRAY, MEDGRAY, and GRAY in addition to WHITE and DARKGRAY, this program anti-aliases the whole scene by super-sampling by a factor of 2. Even on a rev M CE, this program takes quite a long time to produce a full scene, so I'd run it, set it down, and go make dinner or something. I made a non-AA version of this program, but it's not nearly as cool and has already been done plenty of times.

**Code:**```
"Focus pos
```

0→X

0→Y

20→Z

"Center of lens

0→U

10→V

20→W

"X res

264→S

"Y res

164→T

"X width

20→P

"Y width

15→Q

{WHITE,LTGRAY,MEDGRAY,GRAY,DARKGRAY→L₁

For(B,T,82,1

For(A,0,S-1

U-.5P+A(P/S→M

V→N

W+.5Q-B(Q/T→O

0→C

For(D,.25(P/S),.25(P/S),.5(P/S

For(E,.25(Q/T),.25(Q/T),.5(Q/T

If O-Z+E<0

Then

If M-X+D≠0

J/((N-Y)/(M-X+D→K

If N-Y≠0

Z/((O-Z+E)/(N-Y→J

0→θ

If abs(fPart(J/10))≥.5

not(θ→θ

If abs(fPart(K/10))≥.5

not(θ→θ

If θ

C+1→C

Else

10→C

End

End

End

If C≤4

Then

L₁(C+1→C

Else

BLACK→C

End

Pxl-On(B,A,C

End

End

prgmRNGTEST

This is an interesting little program that I wrote some time ago, and it took me a while today to decipher exactly what it was meant to do. Essentially, this program tests randIntNoRep(0,9 over and over with a different initial seed for rand, keeping track of which seeds produce random lists closest to {0,1,2,3,4,5,6,7,8,9}. It outputs the random list and the seed that generated it each time it produces a list more accurate than the current most accurately produced list. I don't believe this program ever created a perfect list, and I ran it for probably an hour. I believe I wrote this for golfing purposes, where having a perfect 0-9 list would be very advantageous. You can easily search for different lists by altering the list in the sum( command.

**Code:**```
0→A
```

10→M

{0}→L₂

While 1

A→rand

randIntNoRep(0,9→L₁

sum(not(not(L₁-{0,1,2,3,4,5,6,7,8,9})))→N

If N<M

Then

augment(L₂,{A→L₂

Disp L₁,A

N→M

End

A+1→A

End

prgmRIEMANN

This program is a fairly sophisticated definite integral approximation program, in that it returns the left, right, trapezoidal, and midpoint Riemann sums of an integral with an arbitrary number of divisions, as well as a Simpson's rule approximation and a column that shows each approximations' deviation from the exact answer, all rounded to a specified number of digits. This program was written to streamline an extremely long and boring calculus assignment.

**Code:**```
1→D
```

While 1

Float

ClrHome

If D

Prompt Y₁,A,B

Input "Round to ? decimals:",U

0→D

Input "Num of divisions:",N

ClrHome

Output(1,1,"MTHD VAL ERR

(B-A)/N→H

0→S

For(I,1,N-1

A+IH→X

S+Y₁(X→S

End

(Y₁(A)+S)H→L

(Y₁(B)+S)H→R

(L+R)/2→T

fnInt(Y₁,X,A,B→C

Output(4,1,"L

Output(4,7,round(L,U

Output(4,16,round(C-L,U

Output(5,1,"R

Output(5,7,round(R,U

Output(5,16,round(C-R,U

Output(6,1,"T

Output(6,7,round(T,U

Output(6,16,round(C-T,U

0→M

A+H/2→X

For(I,1,N

M+Y₁(X→M

X+H→X

End

MH→M

Output(7,1,"M

Output(7,7,round(M,U

Output(7,16,round(C-M,U

Output(8,1,"S(2N)

Output(8,7,round((T+2M)/3,U

Output(8,16,round(C-(T+2M)/3,U

Output(10,1,"INT

Output(10,7,C

Pause

End

prgmREVPOL

Finally, something fun! This program simulates a calculator operating using reverse Polish notation. It lacks a fully realized feature set, but it works perfectly fine for addition, subtraction, multiplication, division, exponents, negatives, and floats.

**Code:**```
ClrHome
```

16→dim(L₁

Fill(0,L₁

{102,92,93,94,82,83,84,72,73,74,103,104,95,85,75,65,55,105,45→L₂

{0,1,2,3,4,5,6,7,8,9,31,32,11,12,13,14,15,21,22→L₃

While 1

ClrHome

For(I,1,9

If L₁(I)≠0

Output(10-I,1,L₁(I

End

"0→Str1

Repeat max(K={21,11,12,13,14,15}) or (K=22 and Str1="0

If K=22

"0→Str1

If Str1="0

Output(10,1,"

Output(10,1,Str1

0→K

Repeat K

getKey→K

End

max(L₃*(L₂=K))-(0=max(L₂=K→K

If K≤9 and K≠1

Then

If Str1="0

Then

toString(K→Str1

Else

Str1+toString(K→Str1

End

End

If K=31 and not(inString(Str1,".

Str1+".→Str1

If K=32 and Str1≠"0

Then

If sub(Str1,1,1)="

Then

Output(10,length(Str1),"

sub(Str1,2,length(Str1)-1→Str1

Else

""+Str1→Str1

End

End

End

If K=21

Then

For(I,15,1,1

L₁(I→L₁(I+1

End

expr(Str1→L₁(1

End

If max(K={22,11,12,13,14,15

Then

If K=11

L₁(2)+L₁(1→L₁(2

If K=12

L₁(2)-L₁(1→L₁(2

If K=13

L₁(2)*L₁(1→L₁(2

If K=14

L₁(2)/L₁(1→L₁(2

If K=15

L₁(2)^L₁(1→L₁(2

For(I,1,15

L₁(I+1→L₁(I

End

0→L₁(dim(L₁

End

End

prgmGUESSNUM

Honestly, what's a graphing calculator without good ol' guessnum? This program is ENHANCED guessnum and supports highscores! (I wouldn't be surprised if I have written this program a hundred times.)

**Code:**```
randInt(1,100→N
```

If randInt(1,10)=1

N+.1→N

0→T

Repeat G=N

T+1→T

Input "Guess:",G

If G>N

Disp "Too high!

If G<N

Disp "Too low!

End

Disp "You won in "+toString(T)+" tries!

If T<H

Then

T→H

Disp "New highscore: "+toString(H)+" tries

Else

Disp "Highscore: "+toString(H)+" tries"

End

prgmFIND

This program is a little game that fills your screen with a grid of one character, all except one slightly different character. The goal is to pass all 6 levels as quickly as possible. There is no cursor, you're just supposed to press enter when you've found the odd one out. Honor system, folks.

**Code:**```
ClrHome
```

"θOŚNEFoceLT→Str1

startTmr→T

For(A,1,length(Str1)/2

randInt(1,10→X

randInt(1,26→Y

For(B,1,10

For(C,1,26

Output(B,C,sub(Str1,2A-1+(X=B and Y=C),1

End

End

Pause

End

Disp checkTmr(T

prgmBOUNCE

This program was influenced by one of the cool demo programs in the SUPERHOT pseudo-filesystem. The screen is covered in a collection of angled mirrors denoted by slash and backslash, with dots coming onscreen from the left. Each time a dot hits a mirror, it is reflected by the mirror while also turning the mirror 90 degrees, so the next dot that hits that mirror goes in the opposite direction. The program runs for some time but eventually has a Dim error that I haven't had the time to weed out.

**Code:**```
ClrHome
```

{10,20→dim([A]

Fill(0,[A]

[A]→[B]

For(A,2,9

For(B,2,19

If not([A](A-1,B)) and not([A](A+1,B)) and not([A](A,B-1)) and not([A](A,B+1)) and not(randInt(0,4

Then

randInt(1,2→C

C→[A](A,B

Output(A,B,sub(" /\",C+1,1

End

End

End

0→T

Repeat T=1000

[A]→[B]

If not(fPart(T/1

5→[A](randInt(1,10),1

For(A,1,10

For(B,1,20

[A](A,B→C

If C>2

Then

0→[B](A,B

If C=3 and A≠1

Then

[A](A-1,B→D

If A≠1

Then

If not(D

Then

3→[B](A-1,B

Else

If D>2

Then

3→[B](A-1,B

Else

If D=1

Then

5→[B](A-1,B+1

2→[B](A-1,B

End

If D=2

Then

4→[B](A-1,B-1

1→[B](A-1,B

End

End

End

End

End

If C=4 and B≠1

Then

[A](A,B-1→D

If B≠1

Then

If not(D

Then

4→[B](A,B-1

Else

If D>2

Then

4→[B](A,B-1

Else

If D=1

Then

6→[B](A+1,B-1

2→[B](A,B-1

End

If D=2

Then

3→[B](A-1,B-1

1→[B](A,B-1

End

End

End

End

End

If C=5 and B≠20

Then

[A](A,B+1→D

If B≠20

Then

If not(D

Then

5→[B](A,B+1

Else

If D>2

Then

5→[B](A,B+1

Else

If D=1

Then

3→[B](A-1,B+1

2→[B](A,B+1

End

If D=2

Then

6→[B](A+1,B+1

1→[B](A,B+1

End

End

End

End

End

If C=6 and A≠10

Then

[A](A+1,B→D

If A≠10

Then

If not(D

Then

6→[B](A+1,B

Else

If D>2

Then

6→[B](A-1,B

Else

If D=1

Then

4→[B](A+1,B-1

2→[B](A+1,B

End

If D=2

Then

5→[B](A+1,B+1

1→[B](A+1,B

End

End

End

End

End

prgmNEURAL, prgmNEURALNW, prgmNEURALPL, prgmTICTAC

Finally, I've still managed to avoid deleting these enigmas of programs. I wrote all four on a long coast-to-coast flight a year or so back in an attempt to create a functional artificial intelligence via neural network functioning on my CE. This was created using my very primitive knowledge of neural networks and machine learning, so I'm not sure it ever produced any results. In theory, I think it was supposed to, but perhaps I just didn't run it for long enough. It's supposed to train a neural net how to play Tic Tac Toe.

From what I understand by looking at the code, it seems like prgmNEURALNW intializes the neural net to have 20 neurons in 4 rows, with [A] [B] and [C] used for weights between the rows. It also creates ʟSCR to save (I believe) the scores for each of 8 variations in a generation, and ʟSTAT to save highscores.

**Code:**```
9→dim(⌊IN
```

{54,7→dim([A]

6→dim(⌊N1

{18,7→dim([B]

3→dim(⌊N2

{6,7→dim([C]

2→dim(⌊S1

2→dim(⌊S2

Fill(1,[A]

Fill(1,[B]

Fill(1,[C]

8→dim(⌊SCR

Fill(0,⌊SCR

3→dim(⌊STAT

{1000000,0,0→⌊STAT

prgmNEURAL is certainly the outermost program of the set, as it contains code to randomly alter the weights between neurons.

**Code:**```
ClrHome
```

Output(5,1,"Max Fitness

Output(5,13,⌊STAT(1

Output(6,1,"Generation

While 1

⌊STAT(2)+1→⌊STAT(2

Output(6,13,⌊STAT(2

10000000→⌊SCR(8

For(I,1,7

round(⌊SCR(I),3→⌊SCR(I

End

If max(⌊SCR)>⌊STAT(1

Then

max(⌊SCR→⌊STAT(1

Output(5,13,⌊STAT(1

End

Output(7,1,⌊SCR

0→I

Repeat ⌊SCR(I)=max(⌊SCR

I+1→I

End

For(J,1,54

For(K,1,7

[A](J,I→[A](J,K

If J≤18

[B](J,I→[B](J,K

If J≤6

[C](J,I→[C](J,K

End

End

For(I,1,54

For(J,2,7

[A](I,J)+.05rand-.5→[A](I,J

If I≤18

[B](I,J)+rand-.5→[B](I,J

If I≤6

[C](I,J)+rand-.5→[C](I,J

End

End

For(M,1,7

M→⌊SCR(8

prgmTICTAC

End

End

prgmNEURALPL is called during prgmTICTAC and I believe that the program means "Neural Play" meaning it plays a move as the neural net in the ongoing game of tic tac toe. It passes in ʟJ, which contains each of the 9 squares in the game, and returns ʟS2, containing X and Y coordinates of where the net has chosen to play.

**Code:**```
⌊J→⌊IN
```

Fill(50,⌊N1

For(I,1,9

For(J,1,6

⌊N1(J)+⌊IN(I)[A](6(I-1)+J,⌊SCR(dim(⌊SCR→⌊N1(J

End

End

Fill(50,⌊N2

For(I,1,6

For(J,1,3

⌊N2(J)+⌊N1(I)[B](3(I-1)+J,⌊SCR(dim(⌊SCR→⌊N2(J

End

End

Fill(50,⌊S1

For(I,1,3

For(J,1,2

⌊S1(J)+⌊N2(I)[C](2(I-1)+J,⌊SCR(dim(⌊SCR→⌊S1(J

End

End

round(⌊S1(1)/100,0→⌊S2(1

round(⌊S1(2)/100,0→⌊S2(2

prgmTICTAC officiates each individual game of tic tac toe, and seems to log some calculation of the net's fitness that round into ʟSCR.

**Code:**```
0→R
```

For(Q,1,5

9→dim(⌊J

Fill(0,⌊J

For(I,1,3

For(J,1,3

Output(I,J,"·

End

End

0→D

0→E

0→T

"D: {FAIL,DRAW,WIN,LOSS}

Repeat D

T+1→T

If E=0

Then

Repeat ⌊J(K)=0

randInt(1,9→K

End

1→⌊J(K

Output(int((K-1)/3)+1,remainder((K-1),3)+1,"O"

Else

prgmNEURALPL

3⌊S2(1)+⌊S2(2)+3→K

If K>0 and K<10

Then

If ⌊J(K)=0

Then

1→⌊J(K

Output(int((K-1)/3)+1,remainder((K-1),3)+1,"X"

Else

1→D

End

Else

1→D

End

End

not(E→E

If D=0

Then

If min(abs(⌊J))≠0

2→D

If ⌊J(5)≠0

Then

For(I,1,4

If 0=variance({⌊J(I),⌊J(5),⌊J(10-I

3.5-.5(⌊J(5→D

End

Else

If ⌊J(1)≠0 and (0=variance({⌊J(1),⌊J(4),⌊J(7)}) or 0=variance({⌊J(1),⌊J(2),⌊J(3

3.5-.5(⌊J(1→D

If ⌊J(9)≠0 and (0=variance({⌊J(3),⌊J(6),⌊J(9)}) or 0=variance({⌊J(7),⌊J(8),⌊J(9

3.5-.5(⌊J(9→D

End

End

End

If D<3

50T-(max(abs(⌊S1(1)),abs(⌊S1(2)))≥100)(.5abs(√(⌊S1(1)²+⌊S1(2)²))-50(T≤2→K

If D=3

550-10T→K

If D=4

50T→K

K+R→R

End

R/5→⌊SCR(⌊SCR(dim(⌊SCR

I'm very impressed that you actually scrolled through all of that.