Hextra Patterns Book

Vector Literals

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

Vector Rfln. +X/-X II (→ vector)

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

Vector Rfln. +Y/-Y II (→ vector)

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

Vector Rfln. +Z/-Z II (→ vector)

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

Vector Rfln. +1/-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.

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.

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. I've seen some texts related to this pattern mentioning something called F3, but I couldn't figure out what that means.

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.

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 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.

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.

Bucketing Gamb.: Nums (many nums, num → num set)

Remove num numbers from the top of the stack, then add them to a number set at 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.

Bucketing Gamb.: Vecs (many vecs, num → vec set)

Remove num vectors from the top of the stack, then add them to a vec set at 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.

Bucketing Gamb.: Ents (many entities, num → entity set)

Remove num entities from the top of the stack, then add them to an entity set at 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.

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

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.

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.

This is the online version of the Hextra Patterns documentation.

Patterns

Vector Literals

Vector Literals

Vector Rfln. +X/-X II (→ vector)

Vector Rfln. +Y/-Y II (→ vector)

Vector Rfln. +Z/-Z II (→ vector)

Vector Rfln. +1/-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)

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)

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)

Hextra Constants

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

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)

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

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

Hash Set Manipulation

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

Bucketing Gamb.: Nums (many nums, num → num set)

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

Bucketing Gamb.: Vecs (many vecs, num → vec set)

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

Bucketing Gamb.: Ents (many entities, num → entity set)

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

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

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

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

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

Additive Distillation (set, set → set)

Subtractive Distillation (set, set → set)

Conjunction Distillation (set, set → set)

Exclusion Distillation (set, set → set)

Length Purification (set → num)