# Terminal Commands
# This terminal has super awesome features, with multi-line code areas possible. # Navigate history with up and down arrows. # Press enter to execute, and shift-enter to create a newline in the current code area. # You can swap this behavior by clicking on the [Enter to execute] button above.# Numbers and Basic Math: +- */ ^_
# # a hash symbol means ignore the remaining input to end-of-line, i.e. make a comment. 0.5 # push a number to the stack. a number begins with 0-9, so start with 0. to do fractions. -5.3 # push a negative number to the stack, i.e. - is unary minus if 0-9 follows. +-*/ # standard mathematical operators, postfix notation, operating on numbers already on the stack. % # find remainder of division operation. (can be negative if dividee or divider is negative.) ^ # power, takes next-on-stack as base and top-of-stack as exponent. _ # natural log, determines ln of top-of-stack. # to take an arbitrary log, base B, of some number N: # N_B_/ # infix: log_B(N) = log(N)/log(B) # examples 0.5 2 - # result is -1.5 8.5 2 * # result is 17 5 3 ^ # result is 125 42_ # result is 3.737...# Stack Operators: e dyYp ~ n
# TOS is "top of stack", and NOS is "next on stack." e # identity operator, used for keeping track of stack index when printing the stack. # executes next instruction as is. # CANNOT be used to do scientific notation. d # duplicate: deep copy of TOS. y # copy: shallow copy TOS. numbers and strings get deep copied. Y # double copy: shallow copy NOS and TOS, to same relative positions. p # pop the TOS, i.e., remove it from the stack. ~ # swap the TOS and NOS. n # push number of elements to stack. # examples 5 4Y # yields 5 4 5 e4 6n # if nothing else in the stack, yields 6 e1 5d* # yields 25, duplicates 5 and multiplies together. 5y* # same as 5d* 1 2 3~ # yields 1 3 e2# Statements via Various Parentheses: () [] {}
# All parentheses [] {} () create a statement based on the functions inside; # A statement acts like a single instruction, but can be composed of multiple instructions. # The statements () {} and () differ in their behavior, though. [] # create a normal statement, which acts as one instruction. {} # create a new stack; any internal instructions push elements to this stack. # the new stack appears on the old stack as an array element. () # this statement lowers the stack index without popping the original TOS. (NOS becomes TOS.) # instructions inside the () will act on the original NOS as if it was the TOS. # while the stack index is lowered, # any elements which get pushed to the stack get inserted into the stack, # and the original TOS gets moved up further. # the original TOS will reappear at the end of the () statement. # examples {1 2 3} # pushes the array {1 2 3} to the stack. [45.5 33.3] # yields 45.5 e33.3 1 5d(+) # yields 6 e5# Strings, Print Strings, and Execution Strings: '' "" ``
'' # push a string to the stack. "" # print string to output. `` # execute the enclosed instruction. # this is useful for multi-character instructions, e.g. `function`. (see "Function definitions".) # `` can also be nested inside a '' or "" string, which executes the instruction inside # and then pops the TOS to write to that point in the string. YAY for arbitrary code execution! # examples "hello world!" # this is the hello world program. 'this is a string' # pushed to stack. 3'what is the TOS? it is `y`.' # `y` executes and duplicates what is on the stack (3), which gets popped and written into the string.# Context-dependent Printing: ,;
# The comma and semi-colon are useful for printing the TOS to output, # though in some circumstances (e.g. check out Matrix Definition) they will do different things. , # print TOS and pop it, but don't use a newline after printing. (use a space.) ; # print TOS and pop it, appending a newline to the output. # examples 'hello!'; # prints 'hello!' to output. could also be done with "hello!" (see Print Strings). 1,2,3,4,5; # prints "1 2 3 4 5" to output (newline after 5).# Comparisons, Logic, and Conditional Branching: <=> ?&| !
# NOTE. be very careful, html may get stripped out of things entered into the text boxes. # i.e. don't put < and ! right next to each other... < # push NOS < TOS (result is 0 or 1), after popping both. > # push NOS > TOS (result is 0 or 1), after popping both. = # check if NOS is equal to TOS (result is 0 or 1), after popping both. ? # push logical value of TOS (either 1 or 0), based on value of TOS. & # push logical value (0 or 1) of NOS logical-AND TOS, after popping both. | # push logical value (0 or 1) of NOS logical-OR TOS, after popping both. ! # NOT conditional: branch based on logical value of TOS, and pop it. # execute first subsequent instruction if TOS was logically zero, # otherwise execute the second instruction. # examples 5 3 < # result is e0 4 4 = # result is e1 5 5 > # result is e0 6 0 > # result is e1 123? # stack is 123 e1 0? # stack is 0 e0 3 4& # stack is e1 0 3& # result is e0 3 0| # result is e1 0 0| # result is e0 0!["TOS was zero/null"100]["TOS was non-null"1000] # end stack result is e100 3 4< !["got not branch (>=)"]["got yes branch (<)"]# Loop Operators: jkl x xo
# loops use the letters jkl, which are right in a row, and thus easy to remember! # you can also run a loop a specific number of times (like a for loop) using `x`. l # loop statement; will loop over the next instruction if the jump operator is hit. j # jump back to start of loop, or "continue", though this is required for a loop to repeat. k # kill or quit loop, or "breaK", or kick out of loop prematurely. x # execute next instruction as many times as the TOS tells you to. o # inside an `x` statement, `o` corresponds to how many iterations left you have. # you can breaK outside of an `x` using `k`, or jump back to start of statement with `j`. # in the latter case, the iteration counter will decrease. # examples 10l[?!k"hello `y`!"1-j] # counts down from 10 to 1, leaves 0 on the stack. 10x"hello `o`!" # easier way to do the above, except doesn't leave a 0 on the stack.# Function definitions: abc zZ
# Functions are defined with up to three subsequent instructions. abc # pop the TOS, use a string to define a function name. abc are placeholders for instructions. # the next instruction is interpreted as the function definition, which can use the placeholder instructions. z # define a zero-instruction function, popping the TOS for a function name. Z # define a variable zero-instruction function, popping TOS for a function name. # i.e., the function can be changed later to something else. # examples 'w'abl[a!kbj] # create a while loop with two instructions (`ab`); # the first is executed to check whether to continue the loop, and if so, the second is executed 1 2 3 4 5wn["hi `y`"p] # the first instruction is `n` (number of elements on stack), the second prints a string and pops the TOS 'H'z0.5 # create a constant variable function (pushes 0.5 to stack) 3H* # yields e1.5 'q'z[0.5^] # create a square root function 9q # yields e3 'inv'z[-1^] # create inverse function 9`inv` # yields e0.1111... 'Q'Z0.25 # create variable zero-instruction function Q # yields e0.25 'Q'Z[4/] # redefine Q to divide; requires something on TOS 5Q # yields e1.25 # See also "Dictionary definitions" for some advanced function definition uses.# Dictionary definitions: aa bb cc
# Dictionaries are simply functions with multiple instructions. # They have their own context for functions. # examples 'A'aa # create a dictionary A, which is an identity operation. A['Z'z["hello arizona!"]] # create a subdictionary Z, defined only inside the A context. AZ # call Z from within an A context, prints "hello arizona!" 'B'Aaa # create subdictionary B 'C'ABz["123"] # create sub-sub-function C ABC # prints 123 AB['E'z"four score and seven years ago"] ABE # prints iconic line. # It can get way more complicated than this, but these are the fundamentals.# Matrix Definitions: m ,;
# You can build matrices using the `m` command. # `m` is a loop specification, so you can use the functions `j` and `k` to write the matrix. m # take two arguments from the stack to get matrix dimensions (NOS for rows, TOS for columns), popping them, # and execute next instruction to build the matrix. , # in the instruction after `m`, this pushes the TOS to the matrix. ; # similarly, this pushes the TOS to the matrix, and fills the remainder of the row with zeroes. # examples 2 2 m[1,0,0,1] # build 2x2 identity matrix. # note that if the final instruction is to push a number to the stack, # it will be pushed to the matrix. (i.e., the final 1 did not need a subsequent comma.) 2dm[1;0,1] # equivalent; d duplicates the 2, so the matrix is 2x2. 1 5m[1,2,3,4,5] # create a row vector 0 3dm[1+d,j] # creates a matrix using a loop; loop terminates once last element is written.# Array/Stack Definitions: {} SP Sp Se
# You can build a new stack using squirrely braces: {'instructions go here'} # You can think of the new stack as a resizable array, with dynamically-typed elements inside. # The new stack will appear on your usual stack, and you can manipulate it with the following functions. S # single-instruction dictionary for stack operations. Sp # pop from the stack on the TOS, push it to the main stack. SP # push the element on the TOS to the stack at the NOS. Se # execute the next instruction using the stack on the TOS as the stack to manipulate. # as a technical note, the \ context for Se is the root context, # so that p inside the statement works to pop an element from the stack, rather than executing Sp # example (run commands sequentially) {1 2 3 'hello'} # pushes this new stack to the main stack. Sp # result is {1 2 e3} e'hello' # pops 'hello' from new stack. ' and goodbye!'+SP # pushes 'hello and goodbye' onto the new stack. Se["My message for you is `y`" # execute these instructions within/for the new stack. l(n!k;j) # loop through the elements below the string (using the parentheses ()), printing them ] # return control the main stack# Random Number Definitions: Ru Rs Rr RR
Ru # random unsigned 32-bit integer, from 0 to 4294967295 (inclusive). Rs # random signed 32-bit integer, from -2147483648 to 2147483647 (inclusive). Rr # random real, in range [0, 1) RR # random signed real, in range [-1, 1) # implementation wise, random reals are just random unsigned values divided by 1<<32 (4294967296) # or signed values divided by 1<<31 (2147483648) # to get a number in some range, use % on a random unsigned value. # examples Ru16% # random value from 0 to 15, inclusive.
https://patchsoul.github.io/FAKE