Miscellaneous Complexes
UTF Purification (num/string → string/num)
Swaps between a string of a single character and an integer representing that character.
Uses the UTF-16 character map.
Patterns
A list of all the patterns I've discovered, as well as what they do.
Bubbles
Complex Mathematics
This is a collection of transcripts from a (now defunct) "Mathematics Corps". I'm not sure what use these have, but I would like to know what the researchers were on whilst writing them.
Expressions
Symbolic Purification (str → expression)
Creates a new symbol with the given (single character) label
Many operations that work on numbers can also apply to expressions.
The full list is: Addition, Subtraction, Multiplication, Division, Powers, Absolute, Floor, Ceiling, Sine, Cosine, Tangent, Arcsin, Arccos, Arctan, Sinh, Cosh, Tanh, ArcSinh, ArcCosh, ArcTanh, Vector Pack, Logarithms, Modulo, Minimus, Minimus II, Maximus, Maximus II, And, Or, and Not
In the case of operators that work on booleans, 0 is treated as "false" and any non-zero value is treated as "true".
Substitution Exaltation (expr, expr, expr | num → expr)
Substitutes the third expression/number in place of the second expression within the first.
Equality Purification (expr, expr | num → expr)
Creates an expression that equals 1 if the two expressions are equal, and 0 otherwise.
Piecewise Exaltation (expr, expr|num, expr|num → expr)
Creates a piecewise expression that simplifies to the second argument if the first simplifies to 1.0, otherwise simplifies to the third argument.
Derivation Purification (expr, expr → expr)
Takes in an expression and a lone symbol and returns the partial derivative of the expression with respect to the symbol.
Neo's Exaltation (num, num, expr → matrix)
Takes in a width, height and expression and creates a matrix by substituting i & j-values into the expression corresponding to a position in the matrix and putting the result in the matrix.
Parametric Line (vec, expr → entity)
Summons a parametric line at the given position. The expression given will have a t-value (0-1), x/y/z position, and time (w) substituted in and must resolve to a vector on the line.
Parametric Surface (vec, expr → entity)
Summons a parametric surface at the given position. The expression given will have a u&v-value (0-1), x/y/z position, and time (w) substituted in and must resolve to a vector on the surface
Both Parametric objects can be killed by use of the Kill Bit pattern
Complexities
Additive Distillation (complex, complex/num → complex)
Performs Addition, num will be treated as num + 0i.
Subtractive Distillation (complex, complex/num → complex)
Performs Subtraction, num will be treated as num + 0i.
Longs
Whilst normal numbers in the form of doubles are extremely useful in all sorts of cases, there come many times where they're just not precise enough.
To this end, longs are used. Despite their limitations (such as only storing integers, and a lower maximum value), longs are still useful due to this granularity, each bit of them can be manipulated freely without worry for imprecision.
Long Reflection (→ long)
Just like with normal numbers, Nature is not so generous as to make this easy for us.
(Details on next page)
Thankfully, what each angle does to the count is very similar to the norm, the only differences being:
a sharp left will shift the bits in the count to the left (effectively doubling them)
a sharp right will shift the bits in the count to the right (effectively halving them*)
* Due to a long's inability to contain a decimal, the value will always be rounded down.
Example: 43L
This pattern pushes 43L: (10 + 10 + 1) * 2 + 1 = 43
Long Purification (num/long → long/num)
Converts between doubles and longs
Always truncates the value when converting to long
Arithmetic R. Shift Dstl. (long, num → long)
Shifts all the bits to the right num times while preserving the sign
Quaternionics
Quaternionic Exal. (num, vec → quaternion)
Pushes a Quaternion with num as the real coefficient and the vector's x, y, & z as the coefficients of i, j & k respectively.
Quaternionic Dntg. (quaternion → num, vec)
Pushes the real coefficient and a vector where the x, y, & z components are the coefficients of i, j, & k respectively.
Multiplicative Dstl. (quaternion, num → quaternion)
Performs Multiplication, Scalar if a num & quat are given, Hamiltonian if 2 quaternions are given.
Matrixification (quaternion → matrix)
Pushes a matrix that (should) represent the same rotation as the quaternion
Quaterniation (matrix → quaternion)
Pushes a quaternion that (should) reperesent the same rotation as the matrix
Axis Angle Distillation (vec, num → quaternion)
Pushes a quaternion that reperesents a rotation by the given angle num radias around the given vector.
Great Spells
The spells catalogued here are purported to be of legendary difficulty and power. They seem to have been recorded only sparsely (for good reason, the texts claim). It's probably just the ramblings of extinct traditionalists, though -- a pattern's a pattern.
What could possibly go wrong?
BIT Manipulation
These are patterns to manipulate Block, Item, and Text Displays (BITs for short).
Oddly, Scout's Distillation does not seem to work on these, thus I must depend on Entity Prfn. or Zone Dstn.
Summon Block Display (vector, string →)
Summons a Block Display entity at the given position, displaying the given block. (The string must be the internal name i.e "minecraft:dirt", not "Dirt").
Costs about a Charged Amethyst
Summon Item Display (vector, string →)
Summons an Item Display entity at the given position, displaying the given item (The string must be the internal name i.e "minecraft:stick", not "Stick").
Costs about a Charged Amethyst
Summon Text Display (vector, string →)
Summons a Text Display entity at the given position, displaying the given string. Costs about a Charged Amethyst
Entity Purification: BIT (vector → entity)
Transform the position on the stack into the BIT at that location (or Null if there isn't one)
Zone Distillation: BIT (vector, number → [entity])
Take a position and a maximum distance on the stack, and combine them into a list of BIT's near the position.
Zone Distillation: Not BIT (vector, number → [entity])
Take a position and a maximum distance on the stack, and combine them into a list of non-BIT's near the position.