Hextra Patterns Book

Hextra Basic Patterns

Archer's Distillation II (vec, vec → vec | null)

Like Archer's Distillation, but is able to hit collisionless blocks like tall grass. Costs a negligible amount of media.

Architect's Distillation II (vec, vec → vec | null)

Like Architect's Distillation, but is able to hit collisionless blocks like tall grass. Costs a negligible amount of media.

Sextant Decomposition (entity → number, number)

Transforms an entity on the stack into the pitch and yaw of its looking direction in radians.

I've seen some texts mention something called F3.

For yaw, north is pi, south is 0, east is -pi/2, and west is pi/2.

For pitch, pi/2 is upwards is pi/2, and downwards is -pi/2.

Sextant Purification (entity → number)

Transforms an entity on the stack into the yaw of its body in radians. Yet again, mentions of F3 turn up.

Vector Literals

Interestingly, attaching the tail of any Vector Reflection to the start of Number Reflection makes it return a vector.

Vector Rfln. X II (→ vector)

A head that sharply bends to the left will output a vector along the X axis.

Vector Rfln. Y II (→ vector)

A head that doesn't bend will output a vector along the Y axis.

Vector Rfln. Z II (→ vector)

A head that sharply bends to the right will output a vector along the Z axis.

Vector Rfln. 1 II (→ vector)

A head that slightly bends to the left will output a vector where all 3 components are the same.

First, I draw one of the eight shapes shown on the prior pages. Next, the angles following will modify a running count starting at 0.

Forward: Add 1

Left: Add 5

Right: Add 10

Sharp Left: Multiply by 2

Sharp Right: Divide by 2.
The clockwise version of the pattern, on the right of the other pages, will negate the value at the very end. (The left-hand counter-clockwise version keeps the number positive).

Once I finish drawing, a vector's pushed to the top of the stack.

Example 1

This pattern pushes (10, 0, 0).

Example 2

This pattern pushes (0, 7, 0): 5 + 1 + 1.

Example 3

This pattern pushes (0, 0, -32): negate 1 + 5 + 10 * 2.

Example 4

This pattern pushes (4.5, 4.5, 4.5): 5 / 2 + 1 + 1.

Hextra Math

Radian Purification (num → num)

Converts an angle in degrees to an angle in radians. Essentially multiplies by pi then divides by 180.

Degree Purification (num → num)

Converts an angle in radians to an angle in degrees. Essentially multiplies by 180 then divides by pi.

Reflection Purification (num/vec → num/vec)

Multiplies the number/vector by -1.

Incrementation Purif. (num → num)

Adds 1.

Decrementation Purif. (num → num)

Subtracts by 1.

Rounding Purification (num/vec → num/vec)

Rounds a number to the nearest integer. If passed a vector, rounds each of its components instead.

Rounding Distillation (num/vec, num → num/vec)

Rounds a number to the nearest multiple of the second number. If passed a vector, rounds each of its components instead.

Entropy Purification (num → num)

Returns a random number between 0 (inclusive) and the number (exclusive).

Entropy Distillation (num, num → num)

Returns a random number between the first number (inclusive) and the second (exclusive).

Scientific Purification (num/vec → num/vec)

Multiplies the input by 10^n or 10^-n, where n is the length of the tail, depending on whether the start is similar to Mult. Dstl. or Div. Dstl.. The top 3 patterns are x10^1, x10^2, and x10^3. The bottom 3 are x10^-1, x10^-2, and x10^-3.

Approach Exaltation (num, num, num → num)

Moves the first value closer to the second by the given amount. Will not overshoot.

Theta Distillation (num, num → num)

Returns the shortest angular distance between two angles in radians.

Turning Exaltation (num, num, num → num)

Turns the first angle towards the second by the given number of radians, picking whichever direction is shorter.

(To make it easier to read, these examples are written in degrees instead of radians.)

For example:

90, 135, 10 → 100 (start at 90, turn 10 degrees towards 135)

10, 270, 30 → 340 (start at 10, turn 30 degrees towards 270)

300, 90, 90 → 30 (start at 300, turn 90 degrees towards 90)

20, 60, 180 → 60 (start at 20, turn 180 degrees towards 60, stop at 60)

Hextra Vector Math

Norm Purification (vec → vec)

Sets the length of the vector to one. Does nothing if the vector is (0, 0, 0).

Length Distillation (vec, num → vec)

Sets the length of a vector. Does nothing if the vector is (0, 0, 0).

Incrementation Purif. (vec → vec)

Increases length by 1. Does nothing if the vector is (0, 0, 0).

Decrementation Purif. (vec → vec)

Decreases length by 1. Does nothing if the vector is (0, 0, 0).

Chaos Reflection (→ vec)

Returns a unit vector facing a random direction.

Distance Distillation (vec, vec → num)

Returns the distance between two vectors.

Approach Exaltation (vec, vec, num → vec)

Moves the first vector towards the second by a given distance. Will not overshoot.

Theta Distillation (vec, vec → num)

Returns the shortest angular distance on a sphere between two vectors in radians

Turning Exaltation (vec, vec, num → vec)

Rotates the first vector towards the direction of the second vector by the given number of radians. Mishaps if the two directions are directly opposite to each other.

For example:

(1, 0, 0), (0, 1, 0), pi/4
→ (0.71, 0.71, 0)

(2, 0, 0), (0, 5, 0), pi/4
→ (1.41, 1.41, 0)

(1, 1, 1), (0, 5, 5), pi/6
→ (0.16, 1.22, 1.22)

Polar Distillation (num, num → vec)

Creates a unit vector from two polar angles, pitch and yaw, in radians. +Y is up. 0 yaw is +Z, pi/2 yaw is -X. Yet again, mentions of F3 turn up.

Polar Decomposition (vec → num, num)

Converts a vector's direction into two polar angles, pitch and yaw, in radians. +Y is up. 0 yaw is +Z, pi/2 yaw is -X. Yet again, mentions of F3 turn up.

Pitch Distillation (vec, num → vec)

Rotates the vector by the given angle in radians around the X axis.

Yaw Distillation (vec, num → vec)

Rotates the vector by the given angle in radians around the Y axis.

Roll Distillation (vec, num → vec)

Rotates the vector by the given angle in radians around the Z axis.

Pitch Purification (num → vec)

Converts an angle in radians to a unit vector where X=0. +Z at 0 radians and +Y at pi/4 radians.

Yaw Purification (num → vec)

Converts an angle in radians to a unit vector where Y=0. +Z at 0 radians and -X at pi/4 radians. Yet again, mentions of F3 turn up.

Roll Purification (num → vec)

Converts an angle in radians to a unit vector where Z=0. -X at 0 radians and +Y at pi/4 radians.

Vector Manipulation

Coordinate Purif.: X/Y/Z (vec → num)

Returns the X, Y, or Z component of a vector.

Coordinate Dstl.: X/Y/Z (vec, num → vec)

Overrides a vector's X, Y, or Z component.

Swizzling Purification (vec → vec)

A family of patterns that "swizzles" a vector's components based on the 3 sections of its tail.

A leftward point represents X, a straight line is Y, and a rightward point is Z.

The first pattern encodes ZXY;
(1, 2, 3) becomes (3, 1, 2)

The second pattern encodes YXX;
(1, 2, 3) becomes (2, 1, 1)

The third pattern encodes YYY;
(1, 2, 3) becomes (2, 2, 2)

The fourth pattern encodes ZZX;
(1, 2, 3) becomes (3, 3, 1)

Vector Purification ([num] | vec → vec | [num])

Converts a list of 3 numbers to a vector, or a vector into a list of 3 numbers.

Hextra Constants

Vector Rfln. +1/-1 (→ vector)

The left-hand counter-clockwise pattern adds (1, 1, 1) to the stack; the right-hand clockwise pattern adds (-1, -1, -1).

Hextra Stack Manipulation

Capsizing Gambit (any → any)

Sends the iota on the top of the stack to the bottom of the stack.

Capsizing Gambit II (any → any)

Like Capsizing Gambit, but copies the iota instead of moving it.

Dredging Gambit (any → any)

Pulls the iota at the bottom of the stack to the top of the stack.

Dredging Gambit II (any → any)

Like Dredging Gambit, but copies the iota instead of moving it.

Angler's Gambit (many → many)

A family of patterns that takes the Nth iota from the top of the stack, determined by the length of the head, and duplicates it in place. The copy will be created right above the original iota.

The first pattern is identical to Gemini Decomposition.

The second pattern, with a head length of 1, duplicates the first iota from the top. [1, 0] becomes [1, 1, 0].

The third pattern follows this. [2, 1, 0] becomes [2, 2, 1, 0].

Hextra Logic

Maximus Distillation (vec, vec → bool)

If the first vector is longer than the second, return True. Otherwise, return False.

Minimus Distillation (vec, vec → bool)

If the first vector is shorter than the second, return True. Otherwise, return False.

Maximus Distillation II (vec, vec → bool)

If the first vector is longer or the same length as the second, return True. Otherwise, return False.

Minimus Distillation II (vec, vec → bool)

If the first vector is shorter or the same length as the second, return True. Otherwise, return False.

Length Equality Dstl. (vec, vec → bool)

If the two vectors are the same length (within small tolerance), return True. Otherwise, return False.

Length Inequality Dstl. (vec, vec → bool)

If the two vectors are not the same length (outside small tolerance), return True. Otherwise, return False.

Range Exaltation (num/vec, num, num, num → bool)

If the first number is between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.

The fourth number seems to describe how to check if the value is in the range.

0: min < val < max

1: min <= val < max

2: min < val <= max

3: min <= val <= max

Range Exaltation II (num/vec, num, num, num → bool)

If the first number is not between the second and third, return True. Otherwise, return False. If the first value is a vector, compare its length instead.

The fourth number seems to describe how to check if the value is outside the range.

0: val < min or max < val

1: val <= min or max < val

2: val < min or max <= val

3: val <= min or max <= val

Non-consuming Logic

Sometimes, I want operate on iotas after using them for logic operations, but it gets rather annoying to have to copy them every time I do. All this copying also places a heavy burden on Nature, especially with large iotas like lists where stack size can be a concern.

Retention Gambit

With some experimentation, I have found that prepending certain logic operations with a clockwise triangle will cause the inputs to not be consumed.

Ret. Gambit: Augur's (A → A, bool)

Convert an argument to a boolean. The number 0, Null, False, and the empty list become False; everything else becomes True.

Ret. Gambit: Equality (A, B → A, B, bool)

If the first argument equals the second (within a small tolerance), return True. Otherwise, return False.

Ret. Gambit: Inequality (A, B → A, B, bool)

If the first argument does not equal the second (outside a small tolerance), return True. Otherwise, return False.

Ret. Gambit: Maximus (A, B → A, B, bool)

If the first argument is greater than the second, return True. Otherwise, return False.

Ret. Gambit: Minimus (A, B → A, B, bool)

If the first argument is less than the second, return True. Otherwise, return False.

Comp. Gambit: Maximus II (A, B → A, B, bool)

If the first argument is greater than or equal to the second, return True. Otherwise, return False.

Ret. Gambit: Minimus II (A, B → A, B, bool)

If the first argument is less than or equal to the second, return True. Otherwise, return False.

Ret. Gambit: Len. Eq. (A, B → A, B, bool)

If the two vectors are the same length (within small tolerance), return True. Otherwise, return False.

Ret. Gambit: Len. Ineq. (A, B → A, B, bool)

If the two vectors are not the same length (outside small tolerance), return True. Otherwise, return False.

Null Coercion

Coalescing Distillation (any, any → any)

If the first argument is not Null, returns it. Otherwise, returns the second argument.

Coalescing Gambit (any, [pattern] | pattern → any)

If the first argument is not Null, returns it. Otherwise, executes the second argument, much like Hermes' Gambit.

Hash Set Manipulation

A hash set contains elements in an unordered fashion, and cannot contain duplicates. Excellent for keeping track of whether or not something exists.
Due to a magical process known as 'hashing', access is reduced to nearly O(1), relaxing the burden on Nature.

However, 'hashing' seems to have a different, albeit minor, burden on Nature. Numbers and vectors lose precision in the process of getting inserted into a set, becoming rounded to 4 decimals. This seems to be related to how Nature considers equality.

Vacant Refl.: Num. Set (→ num set)

Push an empty set that can hold numbers to the top of the stack.

Vacant Refl.: Vec. Set (→ vec set)

Push an empty set that can hold vectors to the top of the stack.

Vacant Refl.: Ent. Set (→ entity set)

Push an empty set that can hold entities to the top of the stack.

Integration Distillation (set, (num|vec|entity) → set)

Remove the iota at the top of the stack, then add it to the set. The iota's type must match the set's type.

Insertion Gambit (set, (num|vec|entity) → set, bool)

Remove the iota at the top of the stack, then add it to the set. Return True if it wasn't already in the set, otherwise return False. The iota's type must match the set's type.

Excisor's Distillation (set, (num|vec|entity) → set)

Remove the iota from top of the stack, then remove it set. The iota's type must match the set's type.

Removal Gambit (set, (num|vec|entity) → set, bool)

Remove the iota from top of the stack, then remove it set. Return True if it was previously in the set, otherwise return False. The iota's type must match the set's type.

Locator's Distillation (set, (num|vec|entity) → set, bool)

Remove the iota top of the stack, then return True if the set contains that iota, otherwise return False. The iota's type must match the set's type.

Additive Distillation (set, set → set)

Remove the set at the top of the stack, then add all its elements to the set at the top of the stack. The two sets must be of matching type.

Subtractive Distillation (set, set → set)

Remove the set at the top of the stack, then remove all its elements from the set at the top of the stack. The two sets must be of matching type.

Conjunction Distillation (set, set → set)

Takes the intersection of two sets. The new set will only contain elements that were present in both of the previous sets. The two sets must be of matching type.

Exclusion Distillation (set, set → set)

Takes the exclusive disjunction of two sets. The new set will only contain elements that were present in only one of the two sets. The two sets must be of matching type.

Length Purification (set → num)

Remove the set at the top of the stack, then push the number of elements in the set to the stack.

Ordering Purification (set → list)

Converts the set at the top of the stack to a list. The order is up to Nature's whims.

Disordering Purification ([num]|[vec]|[entity] → set)

Converts the list at the top of the stack to a set. The list must be non-empty and entirely numbers, vectors, or entities.

Bucketing Gambit (many, num → set)

Remove num iota from the top of the stack, then add them to a set at the top of the stack. Must be either all numbers, all vectors, or all entities.

Spilling Disintegration (set → many)

Remove the set at the top of the stack, then push its contents to the stack. The order is up to Nature's whims.

Hextra Lists

Speaker's Decomp. II (list → list, any)

Gets the iota at the front of the list without removing it from the list.

Derivation Decomp. II (list → list, any)

Gets the iota at the end of the list without removing it from the list.

Viewer's Gambit (list, num → list, any)

Gets the Nth iota of the list without removing it from the list. Returns Null if the number is out of bounds.

Separation Gambit (list, num → list, list)

Splits a list at the given index. [a, b, c, d, e], 2 will return [a, b], [c, d, e].

Elimination Gambit (list, any → list, bool)

Remove the iota at the top of the stack, then remove the first instance of it from the list. If that iota was in the list, return True. Otherwise, return False.

Elimination Gambit II (list, any → list, num)

Remove the iota at the top of the stack, then remove all instances of it from the list. Returns the number of removed occurrences.

Swindler's Distillation (list, num → list)

Reorders the elements of a list the same way Swindler's Gambit reorders the stack. Inputting a negative code will reorder the elements at the start instead of the end.

Shuffling Purification (list → list)

Shuffles the order of elements in the list.

Birdkeeper's Gambit (many → many, list)

An infinite family of patterns that creates a list out of iotas on the stack based on a sequence of dips and lines.

Each dip represents an iota to be drawn into the list. Leftover iotas remain where they are.

The first pattern will produce an empty list when drawn.

The second pattern will make a list from the 3rd and 2nd iota on the stack.

The third pattern will take in the 7th, 5th, 4th, and 1st iota on the stack.

Hextra Meta-Evaluation

Helios' Gambit (any, ([pattern] | pattern) → many)

Casts a pattern or list of patterns like Hermes' Gambit if the next iota from the top of the stack is considered True by Nature.

Selene's Gambit (any, ([pattern] | pattern) → many)

Casts a pattern or list of patterns like Hermes' Gambit if the next iota from the top of the stack is considered False by Nature.

Acheron's Gambit (any →)

Forcibly halts a Hex like Charon's Gambit if the iota at the top of the stack is considered True by Nature.

Styx's Gambit (any →)

Forcibly halts a Hex like Charon's Gambit if the iota at the top of the stack is considered False by Nature.

Djehuty's Gambit ([pattern], list → list)

Casts like Thoth's Gambit, however the new stack for each element additionally has the index of that element added to the top.

Anubis' Gambit (many, [pattern], list → many)

Casts like Thoth's Gambit, however each sub-execution operates on the main stack instead of copies of the stack.

Ra's Gambit (many, [pattern], list → many)

Casts like Djehuty's Gambit, however each sub-execution operates on the main stack instead of copies of the stack.

This is the online version of the Hextra Patterns documentation.

Patterns

Hextra Basic Patterns

Archer's Distillation II (vec, vec → vec | null)

Architect's Distillation II (vec, vec → vec | null)

Sextant Decomposition (entity → number, number)

Sextant Purification (entity → number)

Vector Literals

Vector Literals

Vector Rfln. X II (→ vector)

Vector Rfln. Y II (→ vector)

Vector Rfln. Z II (→ vector)

Vector Rfln. 1 II (→ vector)

Example 1

Example 2

Example 3

Example 4

Hextra Math

Radian Purification (num → num)

Degree Purification (num → num)

Reflection Purification (num/vec → num/vec)

Incrementation Purif. (num → num)

Decrementation Purif. (num → num)

Rounding Purification (num/vec → num/vec)

Rounding Distillation (num/vec, num → num/vec)

Entropy Purification (num → num)

Entropy Distillation (num, num → num)

Scientific Purification (num/vec → num/vec)

Approach Exaltation (num, num, num → num)

Theta Distillation (num, num → num)

Turning Exaltation (num, num, num → num)

Hextra Vector Math

Norm Purification (vec → vec)

Length Distillation (vec, num → vec)

Incrementation Purif. (vec → vec)

Decrementation Purif. (vec → vec)

Chaos Reflection (→ vec)

Distance Distillation (vec, vec → num)

Approach Exaltation (vec, vec, num → vec)

Theta Distillation (vec, vec → num)

Turning Exaltation (vec, vec, num → vec)

Polar Distillation (num, num → vec)

Polar Decomposition (vec → num, num)

Pitch Distillation (vec, num → vec)

Yaw Distillation (vec, num → vec)

Roll Distillation (vec, num → vec)

Pitch Purification (num → vec)

Yaw Purification (num → vec)

Roll Purification (num → vec)

Vector Manipulation

Coordinate Purif.: X/Y/Z (vec → num)

Coordinate Dstl.: X/Y/Z (vec, num → vec)

Swizzling Purification (vec → vec)

Vector Purification ([num] | vec → vec | [num])

Hextra Constants

Vector Rfln. +1/-1 (→ vector)

Hextra Stack Manipulation

Capsizing Gambit (any → any)

Capsizing Gambit II (any → any)

Dredging Gambit (any → any)

Dredging Gambit II (any → any)

Angler's Gambit (many → many)

Hextra Logic

Maximus Distillation (vec, vec → bool)

Minimus Distillation (vec, vec → bool)

Maximus Distillation II (vec, vec → bool)

Minimus Distillation II (vec, vec → bool)

Length Equality Dstl. (vec, vec → bool)

Length Inequality Dstl. (vec, vec → bool)

Range Exaltation (num/vec, num, num, num → bool)

Range Exaltation II (num/vec, num, num, num → bool)

Non-consuming Logic

Retention Gambit

Ret. Gambit: Augur's (A → A, bool)

Ret. Gambit: Equality (A, B → A, B, bool)

Ret. Gambit: Inequality (A, B → A, B, bool)

Ret. Gambit: Maximus (A, B → A, B, bool)

Ret. Gambit: Minimus (A, B → A, B, bool)

Comp. Gambit: Maximus II (A, B → A, B, bool)

Ret. Gambit: Minimus II (A, B → A, B, bool)