Everything here uses ZoomStandard.

Lately I have done alot of experementing with using Y functions for full screen graphics. I found that you can actually make very fast and fairly memory efficiant graphics using nothing but Y commands (Y1, Y2 etc). Here is a list of several things that can be done:

Brick Wall:
First set to mode Simul and store 8 to xRes, now store -10(X-20 to Y1 -10 to Y2 and -10 to Y3. Select the graph style that looks like an upside down staircase. Hit graph. You have a Brick Wall. This can be used in program.

Grayscale Bug
This can be used in a program but I can't see any real way to... anywho: use all the same settings as for the brick wall (including the upside down staircase's) except graph different things. -10(X-20)/(X<8 to Y1 and -10(X<8 to Y2.

interesting find :)

Thanks.

Woah that's pretty sweet and awesome find. These are the kind of advances we need

For the brick wall you could set those -10's to 0's so that half the screen is bricks and that is like a background to a room or something

Another thing is yes I noticed this grayscale bug before and it is like wierd cause if you put that stuff you said for grayscale into the graphing screen and graph it then you'll notice on the last line of vertical pixels that it will be flickerless grayscale which is very wierd

Great job documenting these!
The 'grayscale bug' I have noticed, but only when trying to get different shades of blue with the fast contrast setting (it works there too. Try setting the left half of the graphscreen all black, right half clear, and run the bluescale loop. You get Perfect gray and blue!)

that is so sweet, im going to have to look up simulate mode in the manual to figure out how it works tho

dinhotheone: Simulate mode? Of of the top of me head, I'm not completely sure, but I think that it's simultaneaus (sp?) mode, meaning that it graphcs equations simultaneausly, or at the same time.

Super_Speler: Nice work! :thumbup:

psuedo local variables for recursion:
keep a list with the variable name you want, and an index variable measuring your recursion depth. every time you enter a routine that needs the local variable increase the index variable and push onto the variable list with augment{(L)VARNM,{VAL}). every time you exit, decrease the index variable and pop off the variable list with indexvar->dim((L)VARNM

you can access the local variable with (L)VARNM(indexvar)

Ya i didn't really put the correct ending to the abreviation. I understand now.
plus i can't feel to bad since it was an extreme programmer that corrected me. not just one of the regular ones.

This is always something that has annoyed me and I figured I should say it. Shouldnt TI call it concurrently cause it doesn't do it simultaneously. It searches ever vertical row for if a pixel should be on

moved to calc help and support and pinned

I found this earlier:

too roughly 10 seconds longer than this:

So While is faster than if then That is an awesome find.

Did you use StartTmr, a timer, or your own counting for the tests?

wow, thats pretty nasty, the only annoying part is that it might be a pain to break outa that while. i guess you could just do while condition and g, and then change g for it to work like a true if then

I wonder if it is th same for repeat?

Well, Repeat works differently (it always completes the loop at least once).

what is StartTmr?

It is a command built into 84+'s and 84+ SE's which tells you in interger form what time it is. It is used like this:

:StartTmr->T
...Test Code...
:CheckTmr(T

ah ok i see

*bump*

I don't know if this has been said before in another topic but...

optimizes to

Just a play scientific notation. It works just as fast, if not faster than the former.

I don't know about math operations on scientific notation numbers, but I would expect it to be the same. Either way this is a great way to save bytes.

Actually, 10^( is generally a faster way to do the same (or rather, a very similar) thing.

Really? It has been tested?

Yup, it's in basic code timing thingy... I mean 10^( as one token by the way.

Yeah, I understand, cool. I didn't know that. :)

i didn't knew E can be used without a number as prefix o.o

Yep it is very helpful that way

Well I just saw burr post about the graphing vars, and it is very useful!

Now execute u/v and it works as an instruction ;)

example, screenshot? o.o

Holy crap! This could make many things so much easier.
Especially things where you want to save memory.

It's somewhat slower but that can be useful.

Could be used in menus, since it is slower (saving some bytes when needed).

And what's even better is you can save the value of u or v into a normal variable (just checked). Its really useful I can see for using the same formula over and over... hehehe, no need for prgmθTDH anymore, u -> H will got fine, and smaller :)

I suppose I should mention that you can do a similar thing with lists. Try this:

:"randInt(1,3,2->LA
:Disp LA

This could be really useful with xlib ;)..

I actually just tested this today. 10^( takes 6 seconds while E only takes 4 seconds.

(1000 iterations were done by storing 1000 to variable B.)

And they both take the same number of bytes, so I would go with E since it is faster.

Really? Did you use StartTmr? Did you use the 10^( token or write that out?

I used the token. And I ran the programs, respectively, 20 times to make sure that it wasn't just a fluke.

Also, I use getTmr->L1 and getTmr->L2 and then subtract the start time from the end time.

Is getTmr some command I've never heard of?