Ok! Let's dive right into it:


So there are 10 matrices, each of which can (to my knowledge) be 99x99. (Thanks, PT_)

RUNNING TALLY:
99*99*10 = 98010

There are six default lists, and each can store 999 items. Also, you can create your own lists, each storing 999 items, with up to 5 chars, including A-Z, θ, and 0-9. This works out to 190809 items, each taking up 9 bytes, but we won't include that until the end.

RUNNING TALLY:
(999*6)+(999*37^5) = 69274619037 (holy crud)
190809 + 69274619037 = 69274809846 (OMG)

However, you can also store data using pxlOn() and pxlText(). The draw screen is 265 by 165, so you have 43725 spaces to store data.

RUNNING TALLY:
265 * 165 = 43725
69274809846 + 43725 = 69274853571

You have 10 strings, each can hold 0-9, A-Z, theta, and a bunch of assorted tokens that I will leave out. Each can hold 999 characters, giving you 999 * 37, or 36963 data points.

RUNNING TALLY:
9999 * 37 = 369963
69274853571 + 369963 = 69275223534

But wait, there's more! On function mode, and in the [y=] screen, you have 10 functions, each of which can hold a list/string/variable, and can be edited. Mateo says that each can hold 9999 characters, 0-9, A-Z, and θ, and a bunch of assorted tokens that I will leave out, and this adds up to 3699630 chars.

RUNNING TALLY:
10*9999*37 = 3699630
69275223534 + 3699630 = 69278923164

One of the most obvious ways to store data is through the variables, A-Z, Theta, and the finance vars (which people forget about for some reason ). There are a total of 34 variables, and each can store 99 digits, giving us 2376 more spaces to store things.

RUNNING TALLY:
34 * 99 = 2376
69278923164 + 2376 = 69278925540

Then why don’t we (as TI-Basic programmers, that is) use the large multitude of storage spaces, and prefer to instead complain about how you can’t use 2 letter variable names (IDK if that’s what people do. I find myself doing it a lot.)? The answer is simple: Memory.

69278925540 = about 69.25 GIGABYTES!

This leaves us absolutely no space for any programs at all .

The End!

(If I screwed up, please tell me)

DISCLAIMER:
Not including headers, as the amount is already insane...

This is a more correct calculation:

Code:

Also, flash ROM memory = 3MB large.

Fixed.

This is completely flawed, you seem to be implying that you can store "about 69.25 GIGABYTES!", but the calculator only has so much memory, try doing it, and you will see that you will run out of memory WAYYY before reaching a single gigabyte (each 999 element list will take up 9kb, so after something like 400 lists, you would run out of memory and no longer be able to create any more lists). I guess if you were to multiply the numbers together, you could calculate how many possible states the calculator could be in (which would include every single program ever made and every single program never made ), but that number would be quite useless, and an easier and more accurate way to do it would be to take the entire memory and treat it as one big binary number. That number (the entire memory filled with 1s) is the very large number I'm talking about.
Also, IDK about you, but my CE has a color screen. In ti-basic, you've got 15 colors for each pixel.

You could however, treat your computer (using TI-connect) as a *very slow* kind of hard drive for the calculator, building up your lists, and when your memory is full flush it to the computer
But that might not be too useful for programs

Numbers are not 99 digits. They are 9-byte BCD floating-point numbers.

The size of the RAM + ROM minus memory spaces occupied by TI-OS is the real amount of storable memory. The question, however, is which data type can be used to allocate the greatest amount of memory, which I would believe to be a matrix.

You also need to take into account all possible settings.

I think the variable that can be the biggest is a list (If we ignore the appvars and programs, which can be 64kb, and apps, which can be as big as you want as long as it is a whole number of pages), because the ti-os won't let you create a matrix that is more than 400 elements, (the 99 actually is the limit to either the X or Y dimensions, but you can't do 99x99, the number of elements has to stay under 400, so you can do 99x4, but not 99x5). A list however, can take 999 elements, and if a single one of them is imaginary, then they are all treated as imaginary numbers, which take 18 bytes instead of 9. The bad part about it is that a list is either imaginary or not, so if you create a 999 element list filled with 0s, the size will be about 9kb, but if you set the first number to like 1+2i, then the size of the list will jump to 18kb. Matrices on the other hand can not hold imaginary numbers, and therefore, can only reach a size of about 400x9=3.6kb.

Strings can be the largest variables. End of story.

*Mateo runs away*

Let me explain my thinking:

You can store any number up to 10^100 in a variable. Using some (somewhat) clever trickery, they can be split up into 99 numbers (0-9) that can be edited independently.




I'll answer the second part first: try doing pxlTest on pixels that are different colors. Does it really matter ?

And yes, you will run out of memory LONG (like less then 1/10th of 1 percent in to it) before you finish.

This was all just a thought experiment I came up with because I had too much free time


*Pulls Mateo back*
Yes, strings can be as long as you need them (i.e. Only limited to the RAM size), but I'm limiting it to 9999 to simplicity.

why 9999? why not 2^32-1?

Not really. The most you can get is 14 digits, and while you can extract the rest of them too, they will not hold any data because it is rounded off.
The calculator stores up to 12 decimal digits of data normally, plus, with relatively great effort, two more digits in the 10-exponent (a*10^b).

All other digits are rounded an thus chopped off.

You can store an unlimited amount of storage because you may remove the files from a group onto your PC or another calculator... I mean if it counts... you be the judge of that
if that's not your thing to count then..
The ti-83 series has...
27 kB RAM
160 kB flash ROM
and
Firmware memory 512 kB
ti-84 series
128 KB or 48 KB RAM (depending on hardware revision) of which 24 KB are user accessible.
Firmware memory 1MB Flash ROM (480 KB user-accessible)
ti-nspire series
User memory 100 MB
Memory register 64 MB

No. And it isn't technically unlimited. For me, that amount is nearly 20 terabytes, but you are limited by (prepare for insanity) the amount of materials in the universe. I.E. you cannot store a Googolplex (which is 10^(10^100), as there aren't that many (this is all speculation) atoms.)

It's a valid point, but it makes hash of the whole principle.

true but you may use paper, stone tablets etc

You can store much DATA in MATH!

*runs*

Well how hard would it be to make a operating system that checks how much memory it has?
I mean that's like the only way to know for sure right?
Well unless ti-connect tells you how much memory is on your calculator I have never used ti connect!

/me hands SeeGreatness [2nd] + [+] + [2]

Gee, if only there were a way to check how much memory is available on calculators! I guess there is absolutely no way to know how much memory there really is.