Googology Wiki
Googology Wiki

C notation i think[]

if this exists then tell me so i can change it. work in progress!!!

C notation will be a flow-based notation. A variable starts at 0 and gets changed by parameters/'blocks'.

Each bock has an index which will be important in the Arrow Blocks.

The variable will be represented as , which will be important in Conditional.

List of 'blocks':

Operational Blocks[]

  • - Factorial the variable.
  • - Set the variable to a value.
  • - Set the variable to 0.
  • - Modulo the value by a.
  • - Multiply the variable by a.
  • - Divide the variable by a.
  • - Group blocks. Blocks here start their own indexes, and the itself is treated as one block.
  • - Subtract by A.
  • - Decrement.
  • - Add by A.
  • - Increment.
  • - Flip (multiply by -1).

Arrow Blocks[]

  • - Backshift to the nearest Operational Block.
  • - Do () if {} is true.
  • - Do the first () if {} is true, otherwise do the left ().
  • - Skip the next block.
  • - Go back to the beginning.
  • - Go back to the beginning of the group you are in. (Includes Conditionals, Binary Converts, ETC.).
  • - Stop the loop and return the variable. (Also happens when the iterator reaches the last block after executing it.)
  • - Jump to a block at index a.
  • - Repeat () a times.

Format[]

There are a few key rules to C.

  • Every block is separated by a comma (,). Example:
  • There cannot be an infinite loop that is unavoidable, for example:
  • There cannot be a function that does not change v, for example:

The way C is formatted goes as follows. Here is an example for a function that adds 3 to a number.

  • Sets v to x
  • Repeats 3 times:
    • Increment V

Advanced Blocks[]

There are a few advanced/niche blocks. Here they are:

  • - Do any function. You must set v to it though. For example, a TREE(v) would look like this:
  • - Forward Values. Rush forward, having both a and b as variables, running each block they hit on them, until they are equal. If this happens, set V to that value and continue. If it reaches the end, return the current value of V.
  • - Group the subsequent blocks without an end.
  • - Run through, skipping all operational blocks until it reaches the end or a Runstopper. Ignores other run-throughs.
  • - Runstopper. Stops a run through.
  • - Binary Convert, convert V to binary. Run all B blocks inside the conditional. B blocks allowed only inside it, but Arrow Blocks are allowed. Once it finishes, convert back to standard. If it is ever exited by a , convert to standard.
    • - Binary shift right. Shift to the right.
    • - Binary shift left. Shift to the left.
    • - Flip the binary's order. Example 1010 becomes 0101.
    • - Binary flip. Example 101 becomes 010.
    • - Convert to standard. Converts to standard and exits out of the Binary Convert statement.

Other Controls[]

Certain symbols change some blocks functions. Here they are:

  • - Makes an operational block flip operation side. Example: would be , but would be .
  • - Sets the number of uses a block has. Normally, they can be used endlessly, but here, it sets how much they can be run. After that, they dont do anything. Example: . would run only 3 times, as in the 4th pass, it'd use up all its passes, and not be run. So, this would increase v by 3.