Printer

Re: Printer

Wed, 01 May 2019 18:15:42 +0000

HEX0, HEX1, HEX2, etc. are all list names. Just type them in as their letters.

Re: Printer

Wed, 01 May 2019 16:50:25 +0000

Where do you find ¨Hex0¨?

Re: Printer

Mon, 29 Apr 2019 22:26:57 +0000

Now, you have to keep in mind that when you are reading all of the pixels on the graph screen, the operations will take a while. However, here are the two programs I made as samples. I made them for monochrome, but it should only be a matter of adjusting the window size for color.

Reader:

//Define the hex value mapping {0,0,0,0→HEX0 {1,0,0,0→HEX1 {0,1,0,0→HEX2 {0,0,1,0→HEX3 {0,0,0,1→HEX4 {1,1,0,0→HEX5 {1,0,1,0→HEX6 {1,0,0,1→HEX7 {0,1,1,0→HEX8 {0,1,0,1→HEX9 {0,0,1,1→HEXA {1,1,1,0→HEXB {1,1,0,1→HEXC {1,0,1,1→HEXD {0,1,1,1→HEXE {1,1,1,1→HEXF {0,0,0,0→READ "?→Str0 //Define the screen size //This example is for a monochrome calculator such as the TI-84 0→Xmin:94→Xmax 0→Ymin:62→Ymax For(Y,Ymin,Ymax-2,2 For(X,Xmin,Xmax-2,2 pxl-Test(Y,X→ʟREAD(1 pxl-Test(Y,X+1→ʟREAD(2 pxl-Test(Y+1,X→ʟREAD(3 pxl-Test(Y+1,X+1→ʟREAD(4 Pxl-Change(Y,X If 0=sum(ʟREAD:Str0+"0→Str0 If 1=sum(ʟREAD:Then If not(sum(ʟREAD≠ʟHEX1:Str0+"1→Str0 If not(sum(ʟREAD≠ʟHEX2:Str0+"2→Str0 If not(sum(ʟREAD≠ʟHEX3:Str0+"3→Str0 If not(sum(ʟREAD≠ʟHEX4:Str0+"4→Str0 End If 2=sum(ʟREAD:Then If not(sum(ʟREAD≠ʟHEX5:Str0+"5→Str0 If not(sum(ʟREAD≠ʟHEX6:Str0+"6→Str0 If not(sum(ʟREAD≠ʟHEX7:Str0+"7→Str0 If not(sum(ʟREAD≠ʟHEX8:Str0+"8→Str0 If not(sum(ʟREAD≠ʟHEX9:Str0+"9→Str0 If not(sum(ʟREAD≠ʟHEXA:Str0+"A→Str0 End If 3=sum(ʟREAD:Then If not(sum(ʟREAD≠ʟHEXB:Str0+"B→Str0 If not(sum(ʟREAD≠ʟHEXC:Str0+"C→Str0 If not(sum(ʟREAD≠ʟHEXD:Str0+"D→Str0 If not(sum(ʟREAD≠ʟHEXE:Str0+"E→Str0 End If 4=sum(ʟREAD:Str0+"F→Str0 Pxl-Change(Y,X End End sub(Str0,2,length(Str0)-1→Str0

Printer:

//Define the hex value mapping {0,0,0,0→HEX0 {1,0,0,0→HEX1 {0,1,0,0→HEX2 {0,0,1,0→HEX3 {0,0,0,1→HEX4 {1,1,0,0→HEX5 {1,0,1,0→HEX6 {1,0,0,1→HEX7 {0,1,1,0→HEX8 {0,1,0,1→HEX9 {0,0,1,1→HEXA {1,1,1,0→HEXB {1,1,0,1→HEXC {1,0,1,1→HEXD {0,1,1,1→HEXE {1,1,1,1→HEXF {0,0,0,0→PRNT //Define the screen size //This example is for a monochrome calculator such as the TI-84 0→Xmin:94→Xmax 0→Ymin:62→Ymax ClrDraw AxesOff GridOff Full Str0→Str2 For(Y,Ymin,Ymax-2,2 For(X,Xmin,Xmax-2,2 Pxl-Change(Y,X sub(Str2,1,1→Str1 Pxl-Change(Y,X If Str1="0":Goto S If Str1="1":ʟHEX1→ʟPRNT If Str1="2":ʟHEX2→ʟPRNT If Str1="3":ʟHEX3→ʟPRNT If Str1="4":ʟHEX4→ʟPRNT If Str1="5":ʟHEX5→ʟPRNT If Str1="6":ʟHEX6→ʟPRNT If Str1="7":ʟHEX7→ʟPRNT If Str1="8":ʟHEX8→ʟPRNT If Str1="9":ʟHEX9→ʟPRNT If Str1="A":ʟHEXA→ʟPRNT If Str1="B":ʟHEXB→ʟPRNT If Str1="C":ʟHEXC→ʟPRNT If Str1="D":ʟHEXD→ʟPRNT If Str1="E":ʟHEXE→ʟPRNT If Str1="F":ʟHEXF→ʟPRNT Pxl-Change(Y,X If ʟPRNT(1:Then:Pxl-On(Y,X:Else:Pxl-Off(Y,X:End If ʟPRNT(2:Then:Pxl-On(Y,X+1:Else:Pxl-Off(Y,X+1:End If ʟPRNT(3:Then:Pxl-On(Y+1,X:Else:Pxl-Off(Y+1,X:End If ʟPRNT(4:Then:Pxl-On(Y+1,X+1:Else:Pxl-Off(Y+1,X+1:End Lbl S If length(Str2)>1:sub(Str2,2,length(Str2)-1→Str2 End End

The way I did it is probably not the fastest or cleanest, but it works and shows what I was trying to say

Re: Printer

Mon, 29 Apr 2019 16:44:01 +0000

cool!

Re: Printer

Mon, 29 Apr 2019 15:48:11 +0000

I'll draw up some sample code later when I have more time

Re: Printer

Mon, 29 Apr 2019 15:18:18 +0000

I have not heard of this method before. How do you do this?

Re: Printer

Mon, 29 Apr 2019 13:40:35 +0000

O.o My head hurts from reading this.

Re: Printer

Mon, 29 Apr 2019 13:33:54 +0000

I remember doing something like this last year, except that it would keep list data in a picture variable. It was really slow, and the binary compression was a bit slow, but it stored numbers 0-255 in 8-bit binary partitions. It was great for game file storage, and my friend who was writing an RPG for the +CE at the time ended up using it for game storage. My calculations at the time showed that it could hold a max of 265 * 165 = 43725b, and therefore using 8 bit partitions could hold 5465 numbers. Eventually we decided to optimise this for the game, and we were able to process all of the data with matrix multiplication by moving partitions of data into matrices. On a bit of a tangent regarding the power of matrices in these instances, a couple of weeks ago I used matrices to write a program for calculating discrete Fourier transforms, more of a novelty than anything else. Without matrices, the program ran for 86 seconds at best. With matrices, it took about 3 seconds. My point is that in my experience, matrices are able to simplify programs handling plotting information on the graph screen.

Re: Printer

Sun, 28 Apr 2019 01:28:09 +0000

My "hex" compression would also work with larger bases too, although it grows quickly. To account for all the permutations, its 2^n where n is the number of pixels in the group. I just used hex as its a fairly common base, easy to work with, and easy to "read". If you went with a 3*2 grouping of pixels it would make your string about 3,000 points shorter, but would increase the amount of comparisons you would have to do in determining the proper compression value. Going from a group of 4 pixels to a group of 6 pixels is the same as going from Hex encoding to Base64 encoding.

Another option might be run length encoding, but would be hard to make it reliably fall within the 999 limit of lists. Basically, you record the state at which the pixel is, and how many in a row there are. The wikipedia article on it explains it fairly well.

Re: Printer

Sat, 27 Apr 2019 20:25:56 +0000

If you want to stick with list-based storage, then base 10 compression is an alternative. A group of 46 pixels (treated as binary digits) can be converted into a single 14-digit number in base 10 (the precision of numerical storage is 14 digits, and $2^{47}$ is just a tad too large), and with 164x264 = 43296 pixels to store this amounts to 942 list entries. Just barely within the limit! It's not quite as clean as Trenly's hex compression, but it allows for list manipulation if that's something you need to do.

Re: Printer

Sat, 27 Apr 2019 18:15:07 +0000

Have you thought about compression? If you take each group of n*n pixels, and call that a point, you could possibly store the points instead of pixels using a conversion table. For example, with a 2*2 point layout, it generates 16 possible values, which could correspond to hex values 0-F.

00 00 10 00 01 00 00 10 00 01 11 00 10 10 10 01 01 10 01 01 00 11 11 10 11 01 10 11 01 11 11 11

If you scan the screen in this way, you cut the number of rows and columns in half. You then read those 4 pixels, and determine the layout. Then you take the hex equivalent for that point layout and store it to a string.

This would mean a string like: “0A15F” would correspond to the following points, where 1 is on and 0 is off:

0000010011 0011000111

Repeat for each group of pixels. You also then only are limited by string memory, and not list memory.

Re: Printer

Sat, 27 Apr 2019 16:53:21 +0000

Ok so after trying it out some more, I realized that there are way to many pixels to store. Only like 2% of the entire screen can be stored (assuming that the screen has all of its pixels turned on) because the list can only hold 999 numbers.

Printer

Tue, 23 Apr 2019 17:15:13 +0000

This code has no usefulness, but it looks cool. You draw anything on the graph screen, and the program will store it to L₁ and L₂. The way it works is it scans the whole graph for turned-on pixels using pxl-Test( and stores their X & Y pixel coordinates to L₁ and L₂, respectively. It then clears the graph screen and prints out the image, pixel by pixel. The problem is that the scanning/storing part is really slow on my TI-84 Plus CE. And I mean reeeeeeaaaaaaaly slow. If their is any way to speed the program up, please let me know.

ClrHome 1→dim(L₁ 1→dim(L₂ For(Y,0,164 For(X,0,264 If pxl-Test(Y,X Then augment(L₁,{X→L₁ augment(L₂,{Y→L₂ End End End ClrDraw For(X,2,dim(L₁ Pxl-On(L₂(X),L₁(X),BLACK End