User:BoundedBeans/My Funge-98 fingerprints

From Esolang
Jump to navigation Jump to search

This is a list of custom Funge-98 fingerprint specifications made by User:BoundedBeans. They are currently all unimplemented.

FOEA

Bitstring: 0x464f4541

This fingerprint contains various for-each block constructs. There is a per-ip storage containing a stack of for-each data units. A unit contains a vector for the start of the block, a vector for the end of the block, a vector for the start of the rectangle Funge-space to be iterated over, a vector for the size of that rectangle, and a vector for the current position within the iterated rectangle.

Instructions

B ( - ): Jump to the E, break out of the loop, pop an entry from the for-each stack.

C ( - ): Acts exactly like E, but isn’t marked specially (functions as a continue statement)

E ( - ): Increments the current position of the iterative rectangle (if it is at the end of x, increments y; if it is at the end of y, increments z; if at the end of z, doesn’t jump back, pops an entry from the for-each stack); jumps back to the position of the for-each start on the stack (the S) plus the IP's current delta, pushes the new current cell in the iterative rectangle onto the stack.

S (Vsize Vpos Vend - c): Pops a vector for the end of the loop block (there should be an E instruction at that coordinate, otherwise this will act like r) (mainly useful for the B instruction), pops a vector for the lowest position of the rectangle to iterate over, and pops a vector for the size of the rectangle. Pushes this information to the for-each stack, along with its own coordinate. Pushes the first cell in the iterative rectangle onto the stack.

GRPH

Bitstring: 0x47525048

This fingerprint is a graphing calculator in Funge-space. There is a per-ip storage containing a list of current expressions.

Instructions

A (a - ): Set currently selected expression.

B (a b - ): Sets currently selected expression to expression a + expression b

C (a b - ): Sets currently selected expression to expression a - expression b

D (a b - ): Sets currently selected expression to expression a * expression b

E (a b - ): Sets currently selected expression to expression a / expression b

F (c - ): Sets currently selected expression to a constant accepted as a single-precision float

G ( - ): Sets currently selected expression to x.

H ( - ): Sets currently selected expression to y.

I (a - ): Sets currently selected expression to abs(expression)

J (a m t - ): Sets currently selected expression to:

  • If t = 0: sin(expression a)
  • If t = 1: cos(expression a)
  • If t = 2: tan(expression a)
  • If t = 3: sec(expression a)
  • If t = 4: csc(expression a)
  • If t = 5: cot(expression a)
  • If 6 < t < 11: The inverse of the function denoted by t - 6
  • If t = 12: (expression a) == 0 ? 0 : 1
    • This allows boolean functions:
NOT a    = 1 - a
a AND b  = a * b
a OR b   = bool(a + b)
a XOR b  = bool((a * (1 - b)) + ((1 - a) * b))
  • If m = 1: Use radians, otherwise use degrees.

K (a b - ): Sets currently selected expression to expression a ^ expression b

L (a b - ): Sets currently selected expression to (log base expression a)(expression b)

M (lowybound lowxbound highybound highxbound widthOfCellY widthOfCellX a b - ): Graphs expression a = expression b. Everything other than b is a single-precision float. If funge-space is Unefunge, does it row by row, going right.

N (lowzbound lowybound lowxbound highzbound highybound highxbound widthOfCellZ widthOfCellY widthOfCellX a b c - ) Does a 3d graph with similar qualities to M. If funge-space is Befunge, does it slice by slice, going down. If funge-space is Unefunge, does it row by row, then slice by slice, going right.

O ( - ): Sets currently selected expression to z.

P ( - ): Sets currently selected expression to pi

Q ( - ): Sets currently selected expression to e

R ( - ): Sets currently selected expression to the golden ratio

S (lowybound lowxbound highybound highxbound widthOfCellY widthOfCellX a b - ): Like M but doesn't store and instead prints to stdout.

T (lowzbound lowybound lowxbound highzbound highybound highxbound widthOfCellZ widthOfCellY widthOfCellX a b c - ) Like N but doesn't store and instead prints to stdout.

You can make a sqrt(x) with x^(1/2)

Graphing

The graph is stored in Funge-space as spaces = false and '@' = true, with x = lowxbound y = lowybound z = lowzbound located at the storage offset and going to the right, down, and whatever the delta 0x 0y 1z represents. The graph should not have any interpolation or smoothing.

SUGU

Bitstring: 0x53554755

This fingerprint is for executing Sugueziume code inside Funge-98. There is a per-ip storage containing a queue of strings, a currently executing string, and an instruction pointer to the currently executing string, which resets back to zero when the current string finishes executing.

Instructions

C (n - ): Pops a cell. If nonzero: Clears the queue. If zero: Deletes the currently executing string.

E (0gnirts[input] - 0gnirts[output]): Execute until the queue is empty. Both input and output are comma-separated strings.

F (0gnirts - ): Breaks typical queue fashion and inserts the strings (comma-separated) at the front. (They can be executed by S to run operations on the queue.)

G (0gnirts[input]? h? b c - 0gnirts[output]?): Pops a character which should be either 'E', 'S', 'X', then pops a cell. If the cell is non-zero, pops a socket handle opened by SOCK to connect to a SugueziNet server. Runs the command corresponding to the character but in Sugueziume++ rather than Sugueziume.

P (n - 0gnirts): Pops a cell. If nonzero: Copies the queue, pushes it as a string onto the stack, elements separated by commas. If zero: Pushes the currently executing string onto the stack.

Q (0gnirts - ): Pops a string off of the stack, enqueues the comma-delimited substrings one by one into the queue of strings. Characters that are not commas, spaces, or uppercase letters are ignored.

S ( - ): Execute the entire currently executing string.

X ( - ): Execute one instruction in the currently executing string.

Y ( - b): Push 1 if this fingerprint supports Sugueziume++, 0 otherwise.

Note: When X or S finishes the currently executing string, another will be dequeued and made the new current string.

TMLT

Bitstring: 0x544d4c54

This fingerprint enables true multithreading, where blocking operations don't stop the entire program.

Instructions

F (0gnirts... n - ): Starts new threads with all of the file names as separate funge spaces, able to communicate with the main program via files. The original ips from this program continue to run.

G ((x2 y2 z2 x1 y1 z1)... n - -1 bytes): Defines the bounds of programs in funge-space, multithreads them as if they were files (it's okay if they create temporary files to store them), behaves similarly to F. However, any modifications to funge-space in the programs also modifies the corresponding cell in the calling program, but only in the specified bounds. The same also happens when the calling program does it in the other direction.

Q ( - b b b) - Pushes 1 if T is supported, otherwise 0, then pushes 1 if F is supported, otherwise 0, then pushes 1 if G is supported, otherwise 0.

T (sox soy dx2 dy2 dz2 x2 y2 z2 dx1 dy1 dz1 x1 y1 z1 - ): This blocks all other ips from running, and creates two ips of a different nature which run at the same time rather than taking turns. The new ips' stack stacks, modes, and fingerprint stacks are copied from the original, while the storage offsets are popped by this command.

Retrieved from "https://esolangs.org/w/index.php?title=User:BoundedBeans/My_Funge-98_fingerprints&oldid=123785"