Yes, the routine for the beta function I used in this post works for complex numbers as well.



If you just want to calculate the gamma function, then you can simplify it to this:

Code:

Where the input is in A and Γ(A) is stored to Ans.

This one doesn't destroy any other variables and may be faster.
You can replace "X" with any character you know won't be in Str2.

Code:

Sentence to list of words
Converts a sentence in string format into a list of words without spaces.
Only works on 68k/Nspire calcs

Code:

Code:

Sums up every pair of elements in Ans, a list. By "Logical Joe" on the Cemetech Discord, golfing the version I wrote last year for a Calc I Riemann-sum solver:

Code:


Golfed-ish but non-radians-dependent version, for what it's worth:

Code:

String to StRiNg
Highly useful routine used to mock a string.
Will convert "Python is the best language" into "PyThOn iS ThE BeSt lAnGuAgE"

TI-84 BASIC fragment:

Code:


68k BASIC function:

Code:

Split String by Delimiter Character

Displays an input string in Str1, using a delimiter ({) as a newline character

Code:


Split String by Delimiter Character 2

Displays an input string in Str1, using a delimiter ({) as a newline character if it is known that the input string will not begin or end with a delimiter character

Code:

Both of these will work if the input string contains no delimiters.

ATAN2()
Just as in most programming languages like C++ all TI calculators have an atan2() function. It's just hidden away.
For the equation: atan2(x,y) use

Code:

Example: tan α = (cos ε sin L)/ cos L
Where ε = 23.43949 and L = 229.24429 degrees.
Solve: R►Pθ(cos L,cos ε sin L) = R►Pθ(cos(229.24429),cos(23.43949)sin(229.24429))
Result: -133.2085302 = 226.7914698 degrees

If you had used tan⁻¹() instead the result would have been 46.7914698 which is wrong by 180 degrees.

Move a character at the homescreen in random directions.

Input:
Press any key to exit the loop
(or build in a other condition or use a for( loop)
Output:
Character at the homescreen which moves in random directions.
Possible directions:
stay, left, right, up, down, diagonal (left-up, right-up, left-down, right-down).
If the character reaches the edge of the screen, the possible directions will be reduced,
so that the position wont get outside of the screen.

This is the fastest way, using the finance vars I% and N:

Code:


And this way is a bit slower, but takes less memory (14 bytes less):

Code:


This routines can be used of course not only at the homescreen,
change the right parameters to adapt it for other borders.

This won't work. All you are doing is adding 1 to R and C until the character is off screen...
Try this instead:

Code:

Oh, I`m so sorry, I forgot to put the -'s before (R>1) and (C>1).
I edited my code above, so that it will work now correctly.

I also replaced the >'s and <'s with ≥'s and ≤'s,
this is (like I know) a very bit faster and takes 1 byte less, because R<10 is now R≤9 (one digit less)

And I tried out your version.
Yours takes only 3 bytes more and takes < 0.01 sec more time per loop than my version,
but I measured this only with a simple loop time calculation program in TI Basic.
If it`s important for you to know exactly which version is the fastest then you have maybe a better way to measure the speed.

Nevertheless, both versions are fast enought.
For drawing a random moving character at the homescreen it`s actually too fast,
because the character will be in a light greyscale and hard to see,
but the routines can be changed to use them for other things

You're right, I assumed lists would be faster because of parser overhead and the horrible speed of randInt but it seems that's not the case.
At the end,

Code:

Should be

Code:

Since Ans is faster than a real var.
In fact, if you really want to save some speed, replace the R variable with a system variable like the finance vars or recursive N. Those save about 0.5ms per call at the cost of 1 byte each (because its a 2-byte token).
You could also replace "13→C" with "MAGENTA→C" if you're on a color calc, which will save 0.07ms.

Parsing Ans(1) / Ans(2) is like parsing two list values which takes more time than parsing just R / C.

But replacing the C's in the Output( commands with a simple Ans saves ~0.3 ms.

In my post above are now two versions of the routine.

Using finance vars is the fastest way, but takes some bytes more like you already said.
(of course MAGENTA→N instead of 13→N)
(and I didn`t replace I%'s in the Output( commands with Ans, cause in this case takes Ans more time)

On the TI-84 Plus CE and TI-83 Premium CE before 5.5.1.0038, dayOfWk( doesn't handle leap days (as in, dayOfWk(2020,2,29 returns a Domain error) here is a version that does.
This takes advantage of the fact that dayOfWk(Y,M,0 is valid.

dayOfWk( With Leap-day Support in 15 bytes

Code:
Unfortunately this does not work 5.5.1.0038+ as day zero was patched and the function thereafter can then handle leap days normally.

That's awesome, I wonder if they know about that bug? Seems like something obvious, I'm surprised they missed that before releasing the OS.

Also:

Remove All Duplicate Characters/Tokens From A String

Takes Str1 as an input and modifies it to not have any duplicate characters.

Code:


Examples:
Code:

You are losing a couple bytes by using |v... Its also a little bit slower to use |v so I would just do this instead.


Code:

Am I missing something?

Code:

That's awesome, way simpler and smaller than mine lol. I don't know why I didn't think of that but nice work

Maybe there is a really easy and dumb way to do this that I'm not realizing but I just thought of a short & sweet way to check if your code is running on a CSE or a CE (without trying to time stuff like a degenerate).
It relies on the fact that TI pushed the clock forward on the CE but foolishly did not adjust the bound for how low you can set the date (Jan 1st 1997)

Detect model of color calc (CSE or CE)
Inputs:
none
Output:
Model in Ans (1 = CSE, 0 = CE)

Code:


Obviously you lose the current date so you could reset it if you really don't want to lose it.

Code:

Laplace Transform (68k)
Performs a Laplace integral transform ℒ{f}(s) of a function f(t)

I have included this not because it is terribly useful for your average TI-89 user, but that the methods I had to take to make the CAS operate properly for this function to work ended up being very funny.


Code: