MoreIotas Book

I've started to understand how the old masters cast their Hexes! It's a bit complicated, but I'm sure I can figure it out. Let's see...

Item Iotas

I have discovered two additional types of iotas I can manipulate.

Item Type Iotas describe a singular item stripped of its properties, such as damage or enchantments.

Item Stack Iotas describe a stack of items as they might appear in my inventory, amount, custom names, enchantments, and all.

It would also seem Item Stack iotas referring to Foci containing other Item Stack iotas are somewhat faulty. A limit to the depth of my thought perhaps.

A list of all the patterns I've discovered, as well as what they do.

Types

Classifier's Purification (any → iotatype)

Remove an iota from the stack, and adds the type of that iota to the stack.

Physician's Purification (entity → entitytype)

Remove an entity from the stack, and adds the type of the entity at that location to the stack.

Sorter's Purification (itemtypable → itemtype)

Remove an iota with an associated item type (for example a location and the type of the block at that location, an item entity, or an item frame) from the stack and returns the item type to the stack (e.g. Grass, Stone, Stick, etc.).

Sorter's Reflection (→ itemtype)

Adds the type of the item in the caster's offhand to the stack if there is one present, or the type of the casting hand otherwise.

Entity Distillation: Type (entitytype, pos → entity | null)

Remove an entity type and a position from the stack, and returns an entity of that type at that position if one exists.

Zone Exaltation: Type (entitytype, pos, num → [entity])

Remove an entity type, a position, and a radius from the stack, and returns a list of all entities of that type within that radius of that position.

Zone Exaltation: Not-Type (entitytype, pos, num → [entity])

Remove an entity type, a position, and a radius from the stack, and returns a list of all entities not of that type within that radius of that position

Items

Sorter's Purification (item stack → itemtype)

Transforms the Item Stack at the top of the stack into its Item.

Length Purification (item stack → int)

Transforms the Item Stack at the top of the stack into its size.

Duelist's Purification (entity → item stack)

Transforms the entity at the top of the stack into the Item Stack in its main hand. Also works on Item Frames and dropped items.

Shieldbearer's Purification (entity → item stack)

Transforms the entity at the top of the stack into the Item Stack in its off hand.

Hoarder's Distillation (vector, vector → list)

Removes two vectors from the stack representing position and side. Returns a list of Item Stacks in the block at the given position accessible from the given side (or all if second vector is zero).

Collector's Distillation (vector, vector → list)

Removes two vectors from the stack representing position and side. Returns a list of Items in the block at the given position accessible from the given side (or all if second vector is zero).

Treasurer's Distillation (item stack, int → list)

Transforms the Item Stack at the top of the stack into its size.

Matrices

Matrices are a helpful tool for manipulating vectors to do as I wish, able to represent any linear transformation that can be applied to a vector. Of note with these patterns is that many are forgiving with their inputs, accepting in place of matrices things that can be easily mapped to matrices, namely numbers and vectors.

For example, attempting to multiply a 3x3 matrix with a vector, rather than mishapping, will return a new vector. For more information on how to make use of matrices to their fullest potential, the below is a helpful resource.

3blue1brown

Transformation Prfct. (num | vec | list → mat)

Converts the iota on top of the stack into a matrix. This iota can be a number, vector, or list.

If it is a number, it becomes a 1x1 matrix. If it's a vector, it becomes a 3x1 matrix. If it's a list, it must be a list of purely numbers, purely vectors, or purely lists of numbers (each of which must be the same length). If it's a list of numbers it'll be 1 by n, if it's a list of vectors it'll be 3 by n, and if it's a list of lists it'll be n by m, where n is the inner list length and m is the outer list length.

Restoration Prfct. (mat → num | vec | list)

Converts the iota on top of the stack back from a matrix into a number, vector, or list depending on the vector's size.

A 1x1 matrix will become a number. A 1x3 or 3x1 matrix will become a vector. A 3 by n or n by 3 matrix will become a list of vectors, and any matrix not covered by the previous will become a list of lists of numbers, with each inner list being one column of the matrix.

Restoration Prfct. II (mat → [[num]])

As Restoration Purification, except it always returns a list of lists of numbers.

Identity Purification (int ≥ 0 → mat)

Accepts a positive integer n, and returns an n by n matrix with 1 along the diagonal and 0 elsewhere.

Zero Distillation (int ≥ 0, int ≥ 0 → mat)

Accepts positive integers n and m, and returns an n by m matrix of zeros.

Rotation Distillation (vec, num → mat)

Accepts a vec v and number θ, and returns a matrix representing rotating by θ radians around v.

Additive Distillation (mat, mat → mat)

Adds two matrices together; they must have the same number of columns and rows.

Multiplicative Dstl. (mat, mat → mat)

Multiplies the first n by m by with an m by p matrix to get an n by p matrix.

Division Dstl. (mat, mat → mat)

Divides the first n by m matrix with an m by m matrix to get an n by m matrix.

Power Distillation (mat, int → mat)

Accepts a square matrix and an integer, and raises the matrix to the power of the integer.

Multiplicative Dstl. II (mat, mat → mat)

Multiplies the first n by m matrix elementwise with another n by m matrix.

Division Dstl. II (mat, mat → mat)

Divides the first n by m matrix elementwise by another n by m matrix.

Power Distillation II (mat, mat → mat)

Raises the first n by m matrix elementwise to the power of another n by m matrix.

Retrograde Purification (mat → mat)

Accepts an n by m matrix and returns an m by n matrix where every entry has been flipped along the diagonal.

Inverse Purification (mat → mat)

Accepts an n by n matrix and returns the n by n matrix such that in*out = identity.

Determinant Purification (mat → num)

Accepts a square matrix and returns the determinant of that matrix. Mishaps for matrices larger than 4x4.

Tower Distillation (mat, mat → mat)

Accepts an n by m matrix and a p by m matrix and produces a (n+p) by m matrix by putting the first matrix on top of the second.

Sprawling Distillation (mat, mat → mat)

Accepts an n by m matrix and an n by p matrix and produces an n by (m+p) matrix by putting the first matrix to the left of the second.

Toppling Gambit (mat, num → mat, mat)

Accepts an n by m matrix and an int from 0 to n, and returns two matrices created by splitting the input matrix vertically at the inputted int.

Mitosis Gambit (mat, num → mat, mat)

Accepts an n by m matrix and an int from 0 to m, and returns two matrices created by splitting the input matrix horizontally at the inputted int.

Strings

Additive Distillation (str, str → str)

Removes the top two strings from the stack and combines them together.

Separation Distillation (str, str → [str])

Removes the top two strings from the stack and splits the first string, using the second string as the delimiter and returning as a list.

Input Purification (str → num | null)

Removes a string from the top of the stack and returns the number that string parses as (or null if it doesn't parse).

Locator's Distillation (str, str → num)

Removes two strings from the top of the stack, and returns the first index of the first string where the second string is a substring.

Selection Exaltation (str, num, num → str)

Removes a string and two positive integers from the top of the stack, and returns the substring from the first to the second (inclusive first, exclusive second).

Length Purification (str → num)

Removes a string and returns its length.

Blank Reflection (→ str)

Add an empty string to the stack, useful for combining with other strings.

Spacing Reflection (→ str)

Add a blank space string to the stack, useful for combining with other strings.

Comma Reflection (→ str)

Add a comma string to the stack, useful for combining with other strings.

Breaking Reflection (→ str)

Add a string to the stack representing a break between lines, useful for combining with other strings.

Whisper Reflection (→ str)

Adds the last message the caster sent to the stack as a string.

Listener's Reflection (→ str)

Adds the last message anyone sent to the stack as a string.

Sifter's Gambit (str | null →)

Accepts a string; All future chat messages starting with that string won't be seen by others, and only messages prefixed with that string can be read by Whisper Reflection.

Sifter's Reflection (→ str | null)

Returns the last string you passed to Sifter's Gambit.

Reader's Purification (vec → str | [str])

Removes a vector from the stack. If that vector is pointing at a sign or lectern, it returns that sign or lectern's text to the stack. Otherwise, it returns null.

Write (vec, str | [str] →)

Removes a vector and a string from the stack. If that vector is pointing at a sign or lectern, it writes that string to that sign or lectern. Costs a hundredth of an Amethyst Dust.

Scrivener's Purification (any → str)

Converts the iota on top of the stack into a string.

Patternmaster's Prfct. (pattern → str | null)

Converts the pattern on top of the stack into the string for that pattern's name. If there is no action associated with that pattern, or if the associated pattern is a Great Spell, it returns null.

Moniker Purification (entity → str)

Takes an entity and returns that entity's name. If it is an item entity, return the item's name.

Name (str, entity →)

Takes a string and an entity, and sets that entities name to the given string. If the entity is an item entity, also set the item's name. Costs a hundredth of an Amethyst Dust.

Case Distillation (str, bool | null → str)

Removes a string and a bool or null. If it was true, return the string in upper case. If false, lowercase. If null, toggle each character's case.

This is the online version of the MoreIotas documentation.

Hex Casting