Homescreen Vertical Scrolling Engine

I created a nice homescreen vertical scrolling engine for the TI-83+ family. It's specifically written for the CSE, however I will comment with changes if you want to make it a monochrome engine. I intend to use this to make a CSE game of some sort, but I'll have to think.
(I know that there are some quotes left in, but that's for the formatting of the code blocks)

Uses all variables in the DelVar line at the end.

Code:

Nice work, 123outerme! This could certainly be useful. I added in collision detection for walls (Or 'X's in this case), which is easily modifiable for things like collectibles or something. I imagine it could be a tad more optimized, but oh well.


Code:


The above comments also still hold. Of course, now you have to do region checking, but that is useful if you want to leave a level or something.

This is almost surely the smallest way to do it, but when the size of the integers is known, its speed can be improved.

At http://tibasicdev.wikidot.com/forum/t-780769/bitwise-operators
Weregoose suggests, when the integers are 32-bit, to
"Store 2^cumSum(binomcdf(31,0→listname on the side, then use the third line from [what I quoted] (substituting listname for Ans). At 32 bits, this takes 0.448 seconds to execute on a fresh TI-84+SE."
I stored it into L₁; this method takes 0.55 seconds on my 84+ to calculate 0x33333333 xor 0x55555555 (in decimal: 858993459 xor 1431655765), of course not counting precomputing of the list.

At the cost of a byte due to the necessary *, rearranging means we don't need to multiply the whole list by .5. Note that this is a rare case in which L₁⁻¹(A+Bi is faster than (A+Bi)/L₁, probably because it's real list*complex float.

Code:


We can also compute both .5Ans and Ans⁻¹ instead—store them into L₁ and L₂ respectively. Multiplication is faster than division.

Code:


Now, since we're working on a list of 32 numbers, abs( is moderately expensive, and overhead is small. So complex numbers are unnecessary when optimizing for speed.

Code:


Remember that X≥.5 is equal to, when 0≤X≤1, round(X,0), and also the identity A xor B = A+B-2(A and B). Now we have:

Code:

Can anyone do better, maybe with a lookup table? I have 0.24 seconds using a 16x16 matrix as in the thread I linked to, but the code is ugly and the matrix is 2317 bytes.

EDIT: Factoring out 2^-13 from the list helps with speed. Where E=2^-13 and L₂=2^(13-cumsum(binomcdf(31,0))), this is as fast as the matrix method:

Code:

Insert to/pop from a list at a certain index

Inputs:
- L₁ = list to manipulate
- A = Index to insert at/pop from (starts at 1)
- B = Value to insert (if applicable)

Outputs:
Ans = L₁ = modified list

Code:

M. I. Wright, it's usually not a good idea to loop over lists when seq( applies. I believe this is the standard method, found at http://tibasicdev.wikidot.com/forum/t-661155/how-to-delete-single-value-in-a-list#post-1796150:

Code:


Here's another method of note: http://tibasicdev.wikidot.com/forum/t-575692/variable-problem#post-1593505

In general, a stack or list that resizes every time an element is stored or retrieved (as in http://tibasicdev.wikidot.com/stack) is very slow, so try to use a pointer instead.

Edit: Changed first formula to use list index properly.
Edit: Thanks, calc84. That works as it should.

I think the insert could be slightly more optimized like this:

Code:

Frequency of a certain number in a list
Store your list in L₁, and the number you want to find the frequency of in X (meaning the actual number, not where it is in L₁).
Frequency ends up in Ans.

Code:


sum(not(seq(L1(Z)(L1(Z)!=X),Z,1,dim(L1


If the number you want to find the frequency of is 0, this can be simplified to

Code:


sum(not(L1


edit: I'm a complete idiot. See lirtosiast's post below.

Code:

Return a decimal number from a list containing a binary number
Hopefully more efficient than my last two contributions to this thread.

Takes L1 as input, being a list containing a binary number with each element of the list being a single binary digit.

Outputs a decimal number in Ans.

Code:

For instance, an input of {1,1,0,1} would output 13.

This complements Weregoose's routine for converting a number (N) to base B:

Code:

Storing 2->B and a number to N then storing this to L1 will give a list compatible with my routine.

There's probably a way to adapt mine to output to more bases, but I have school in a few minutes so I can't work that out.

This is shorter and faster for binary list evaluation:
Code:

I found a problem with one of the lines of code from the Change Case of a String - one of the 26's should be a 27:


Code:

otherwise, going from uppercase to lowercase would also go back one letter (converting A to Z, B to a, C to b, etc.)

For almost the same size as the "Change Case of a String" routine in the first post of this topic, the following routine completes the same in less than half the time.

Change Case of a String

Inputs:
Str1 = string to convert,
A = (1 to convert to uppercase, 0 to convert to lowercase)
Output:
Str1 = converted string

Code:


Edit: Number of optimizations discussed over SAX.

Here's my non-inline solution, which returns the result in Ans rather than building from the end of Str1 or replacing each character of Str1.


Code:


Here is a version that creates a new string in Str0, not Ans. I estimate it to be faster:

Code:


EDIT: optimized slightly

Shortest Heron's Formula

Takes a list of lengths of sides {a,b,c} in Ans, and gives the area of the triangle in Ans.

Code:

At twelve bytes, it is two bytes shorter than Weregoose's routine below.

Code:

Number to list
Input and output in Ans.

Lirtosiast came up with this short version (we had three total)--

Code:

Dunno how they compare speed-wise, though, so these are the others by me and NoahK respectively:

Code:


where 10^( is the 2nd-LOG token.

not the most optimized, but here's a one way decimal-to-binary converter. it uses a string to keep track of the remainders which turns into the binary number. there are more optimized ones, so don't bother putting this one in the list, but I just thought I'd share:

Code:

where N is the decimal number you want to convert. the expr() is not necessary, but that will allow you to use the number value if need be.

it's actually super fast, even with large numbers. when you get super big numbers, it may go a bit slower obviously, and also you'll have the calculator return E(number) instead of all the 1's and 0's if the binary number is too big.

If you want to return the binary as a float with the decimal digits interpreted as binary, you can just use

Code:

In the text-to-list routine the for loop becomes a seq command


Code:


Shortening it by 3 bytes and making it faster.


The second one is the Modulo Division - this is NOT by me, someone recently posted this Routine in the SAX but I do not remember his name. Anyways, it is awesome.


Code:


Saving two bytes and making it run faster.

EDIT: I just got corrected, the latter routine can produce rounding errors so it is incorrect.

The first routine is already on tibasicdev on the string to list page gz for re-coming up with it tho, happens sometimes, you feel like you've created something awesome and learn that it's already been done xD

Change Case of a String
Inputs:
Str1 to convert
A (1 = lowercase, 0 = uppercase)
Output:
converted string in Str1 and Ans


Code:


Only for the CSE and the CE though, due to the use of remainder()