This is the documentation page for Eternal Notations, a JavaScript library used in conjunction with break_eternity.js to abbreviate very large numbers in various notations. The source code is on GitHub, and you can test out the "preset" notations here.
The boxes below can be clicked to open and close their contents, and likewise for any boxes inside. It is recommended you read at least Part 0 before jumping into the rest of the manual. Part 1 is the most important for immediate use of the library, Part 2 is the most important if you want a deeper understanding.

Part 0: Introduction

You may already be familiar with AD Notations, a notations library for break_infinity.js, and if you are, then Eternal Notations is basically a sequel to AD Notations which works with break_eternity.js instead of break_infinity.js. This library exports a single object, EternalNotations, which contains all of the presets, notations, and methods in the library.

There are two ways to use this library. If you're looking for something like AD Notations, i.e. a bunch of notations that are easy to quickly add to your incremental game, then you'll want to use the Presets, described in Part 1. If you want a set of notations with parameters that let you customize them to your heart's content, potentially creating new notations out of those already there, then you'll want to use the Notations, described in Part 2. Eternal Notations also provides a few extra functions, most of which are used on break_eternity Decimals; these are described in Part 3.

Like in AD Notations, the main method for a preset or a notation is format(value), which takes a DecimalSource (something that can be converted to a Decimal: a number, string, or Decimal) as Parameter and writes that value in that notation. Examples:

new EternalNotations.ScientificNotation().format(1e100);
EternalNotations.Presets.Standard.format("ee50");

Unlike AD Notations, the format method does not have parameters for decimal places - those are covered by the notation parameters, for reasons that will become apparent in Part 2 - it just has the value parameter. Also unlike AD Notations, Eternal Notations typically doesn't distinguish between numbers above 1,000 and numbers below 1,000 - the notations apply to all. Notations in Eternal Notations cover a wider range of numbers than they did in AD Notations, including numbers smaller than 1 (which are ignored by most notations in AD Notations).

Part 1: Presets

To use Eternal Notations in the same way you'd use AD Notations, you'll want to use two objects provided within Eternal Notations: EternalNotations.Presets and EternalNotations.HTMLPresets. These two objects contain all of the presets, which are pre-made, ready-to-use notations. For example, to use the Logarithm notation preset, use EternalNotations.Presets.Logarithm. Note that this does not use the new operator, as the members of Presets and HTMLPresets already exist. Presets and HTMLPresets contain the same notations (with one exception); use Presets when you're outputting to plain text, using HTMLPresets when you're outputting to innerHTML.
There are currently 145 presets. The following is a list of all of them, with what they do written in brackets next to them (the ones written in yellow are functions that take one parameter):

Added in v1.0

Added in v1.1

For more detailed descriptions of the presets, go to the demonstration page.

Part 2: Notations

Support for larger numbers and additional notations to choose from are important, but the big thing that really sets Eternal Notations apart from AD Notations is that the notations have parameters. Some parameters let you make changes to the numbers the notation works in (such as the base of a logarithm, or the degree of a root), some let you change thresholds (such as when a scientific notation switches to another layer of scientific or the maximum amount of characters in Standard), some make aesthetic changes (such as what character is used as the e in scientific notation), and some let you create alternate versions of the notation (such as changing the allowed exponent values in scientific, the digits of a base, the set of digits in roman numerals, or the set of prefixes in SI). Almost all parameters have default values, so you only need to customize them if you want to. Unlike the presets, you do use the new operator here, such as new EternalNotations.LettersNotation() or new EternalNotations.StandardNotation(1, true, 0, undefined, undefined, 6) (The undefineds there cause those parameters to be set to their default values). For the sake of familiarity with AD Notations and to differentiate them from the presets, all of the notations end in the word "Notation". In particular, it should be noted that many notations have one or more "innerNotation" parameters: if a notation has a number left over (such as the mantissa in scientific, Standard, etc.), that number will itself be written in the innerNotation, which is almost always new DefaultNotation() by default.

When this documentation lists function or notation parameters, the types of those parameters have their TypeScript type next to them in parentheses. If the arguments provided are not of the appropriate type, expect errors or invalid behavior. If the type has an exclamation point at the end of it, that means it is a required parameter, which means it does not have a default value and must be included in the parameter list for the notation to work. Even after an instance of a notation has been constructed, its parameters are public so they can be changed (well, internally some are public while others have getters and setters, but you can treat them all as public). Some parameters will throw errors if set to incorrect values (such as trying to give a scientific notation a negative base). Parameters of type Decimal accept any DecimalSource in the constructor, but they might only accept a Decimal when changing them afterwards (I didn't want to go through and add a bunch more getters and setters just for that). Likewise, function arguments of type Decimal will accept any DecimalSource (but if the type of a parameter is itself a function that takes a Decimal, then that function will require a Decimal, not a DecimalSource). In this documentation, parameters (even those that are of function type) will be written in the same color as the rest of the text, usable functions will be written in yellow.

Each notation is its own class, but all of them are extensions of the Notation class. The Notation class provides the following data members and methods (I'm only listing the ones that users of the library need to be concerned with):

The Notation class is abstract, so it has no constructor of its own. The constructors for other notations do not include the six parameters from Notation itself, so if you want to change those, you'll want to use setNotationGlobals and setName.

Now that we've covered the base class, let's get into the rest of the notations. In the source code, the notations are split between two folders inside the src folder: baseline and notations. The notations in baseline are the ones that other notations rely on, while the notations in notations stand on their own. In theory, you could remove one of the notations in the notations folder from the library and all you'd lose would be that notation and a few presets, but the library will probably stop working if you remove one of the notations in the baseline folder. Click any of these boxes to open up information about that notation.

Baseline

DefaultNotation

The default way to abbreviate numbers - any leftover numbers in other notations are typically put through this to add commas and decimal places. Starts with unabbreviated numbers, then scientific notation, then scientific notation with multiple e's, and finally F notation.

AlternateBaseNotation

Behaves similarly to DefaultNotation, but supports alternate bases (any whole-number base between 2 and 64, or higher if you provide your own digits) and has more customization.

SignValueNotation

Given an array of sign-value numerals such as Roman numerals, converts the number into that sign-value system. For example, given the Roman numerals themselves, 325 becomes CCCXXV.

NestedSignValueNotation

A variant of SignValueNotation where the numbers in truncated expressions are themselves notated in this notation. Once the parentheses are deep enough, brackets are introduced to represent the number of parentheses layers, and later on braces are introduced to represent the number of bracket layers.

FractionNotation

Writes a number as a fraction that approximates its value. (The approximation is found via continued fractions).

AppliedFunctionNotation

Applies a function to the value, puts a string before it and/or a string after it, then uses InnerNotation to abbreviate the new value.

ConditionalNotation

Has an array of notations to choose from, selecting one of them to abbreviate the value based on certain conditions.

PredeterminedNotation

This notation, no matter what you put in, returns a particular string. Used for things like Blind notation.

Of the baseline notations, Default, Alternate Base, the Sign Value ones, and Fraction are actual notations themselves, while Applied Function, Conditional, and Predetermined are moreso tools for creating other notations.

Notations added in v1.0

ScientificNotation

Scientific notation. Abbreviates 9 as "9e0" and 10^50 as "1e50". For larger numbers, switches to abbreviations like "e1e17" and eventually "(e^7)1e6", similarly to break_eternity's default toString.

ScientificIterationsNotation

This notation performs scientific notation a certain number of times. 1 iteration means the number is in the form AeB (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form AeBeC, and so on.

LogarithmNotation

Abbreviates numbers in terms of their logarithm, so 10^12 is "e12" and 2 is "e0.301".

MultiLogarithmNotation

A variant of logarithm notation that uses a different amount of logarithm iterations depending on how large the number is.

HyperscientificNotation

Scientific notation, but with tetration instead of exponentiation. Abbreviates 9 as "9F0", 1,000 as "3F1", and 10^10^10^10 as "1F4".

HyperscientificIterationsNotation

This notation performs hyperscientific notation a certain number of times. 1 iteration means the number is in the form AFB (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form AFBFC, and so on.

SuperLogarithmNotation

Abbreviates numbers in terms of their super-logarithm, so 10 is "F1" and 10^10^10 is "F3". Uses the linear approximation of tetration.

MultiSuperLogarithmNotation

A variant of super-logarithm notation that uses a different amount of super-logarithm iterations depending on how large the number is.

ExpandedDefaultNotation

The progression of this notation is similar to Default notation: unabbreviated, then scientific, then hyperscientific. However, this notation is not itself a default: instead, it lets you customize the process.

StandardNotation

Uses the names of large numbers to abbreviate them: a million is 1 M, two billion is 2 B, and so on. Larger names use the -illion scheme devised by Jonathan Bowers.

LettersNotation

Each power of 1,000 gets a letter of the alphabet, so 1,000 is 1a, 55,430,000 is 55.43b, 10^15 is 1e, and so on. aa comes after z, aaa comes after zz. 100A means that there would be 100 lowercase letters in the full expression, 1Aa means 1,000A, 1Ad means (10^12)A, 100B means there would be 100 lowercase letters in an expression beginning with A, 200C means that there would be 200 lowercase letters in an expression beginning with B, and so on. AA comes after Z. 100@ means there would be 100 uppercase letters in a full expression, 1 @a means 1,000@, and so on.

SINotation

Abbreviates a number using the SI prefixes: 1,000 is 1 k, 10^12 is 1 T, 10^30 is 1 Q, 10^33 is 1 kQ, 10^72 is 1 TQQ, 10^300 is 1 Q[10], and so on.

NestedSINotation

A variant of SINotation where the numbers in truncated expressions are themselves notated in this notation. Once the brackets are deep enough, braces are introduced to represent the number of brackets layers.

HyperSINotation

Abbreviates a number using "hyper-SI" prefixes that represent the tetra-powers of 10: 10 is 1 Pl, 100 is 2 Pl, 10^9 is 9 Pl, 10^10 is 1 Dg, 10^100 is 2 Dg, 10^10^9 is 9 Dg, 10^10^10 is 1 Bi, and so on. It's similar to hyperscientific, but with the hyper-exponent replaced by an equivalent prefix abbreviation.

NestedHyperSINotation

A variant of HyperSINotation where the numbers in truncated expressions are themselves notated in this notation.

LetterDigitsNotation

Similar to Letters notation, but without a mantissa: the lowercase letters themselves represent the number, so a is 1, b is 2... z is 26, aa is 27... and so on. Uppercase letters mean the same thing they do in Letters notation: in an expression with an uppercase A, the number (which here is represented by the lowercase letters) represent the amount of lowercase letters that would be in the full expression without the A, an uppercase B expression's lowercase letters represent how many lowercase letters would be in an uppercase A expression, and so on.

MyriadNotation

Uses Donald Knuth's -yllion proposal to abbreviate numbers. In this system, rather than each power of 1,000 getting a new name, each new number name after a hundred is the square of the previous one.

HypersplitNotation

Abbreviates a number by splitting it into hyperoperators like how OmegaNum does, except there's an exponentiation entry between the mantissa and the tetration entry.

FactorialNotation

Represents numbers in terms of factorials, so 24 is "4!" and 720 is "6!".

MultiFactorialNotation

A variant of factorial notation that uses a different amount of factorial iterations depending on how large the number is.

FactorialAmountNotation

Abbreviates numbers in terms of how many times you'd have to apply factorial to 3 to get to them, so 3 is 3!0, 6 is 3!1, and 720 is 3!2.

MultiFactorialAmountNotation

A variant of factorial amount notation that uses a different amount of iterations depending on how large the number is.

FactorialScientificNotation

Like scientific notation, but with factorials instead of exponents. Abbreviates 12 as "2 * 3!" and 16! as "1 * 16!". For larger numbers, switches to abbreviations like "(8 * 17!)!" and eventually "(!5)5.6 * 7!", the latter of which means "start with 5.6 * 7! and take the factorial of it 5 times".

FactorialScientificIterationsNotation

This notation performs factorial-scientific notation a certain number of times. 1 iteration means the number is in the form A * B! (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form A * (B * C!)!, and so on.

FactorialHyperscientificNotation

Like hyperscientific notation, but with repeated factorials instead of tetration. For example, 6 (3!) could be 3!1, 4!2 means 4!! (which is around 6.2e23), and 7!20 means 7!!!!!!... with 20 !'s.

FactorialHyperscientificIterationsNotation

This notation performs factorial-hyperscientific notation a certain number of times. 1 iteration means the number is in the form A!B (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form A!B!C, and so on.

FactoradicNotation

Abbreviates a given number in the "factoradic base", where the place values are the factorial numbers, which means each digit can go one value higher than the previous. Behaves like AlternateBaseNotation for larger numbers, but with factorials instead of powers.

RootNotation

Abbreviates numbers in terms of a root; this is the square root by default, so 64 is 8^2 and 10,000 is 100^2.

IncreasingRootNotation

A variant of root notation that uses a different root height depending on how large the number is.

MultiRootNotation

A variant of root notation that uses a different amount of root iterations depending on how large the number is. Once the amount of iterations gets too high, we go to a higher layer where the amount of iterations is itself written in this notation, and repeat that layering process for larger and larger numbers.

SuperRootNotation

Abbreviates numbers in terms of their super-root; this is the square super-root by default, so 256 is 4↑↑2 and 46,656 is 6↑↑2.

IncreasingSuperRootNotation

A variant of super-root notation that uses a different super-root height depending on how large the number is.

MultiSuperRootNotation

A variant of super-root notation that uses a different amount of super-root iterations depending on how large the number is.

PrimeNotation

Writes numbers as their prime factorization: for example, writes 6 as 2 * 3, and writes 60 as 2^2 * 3 * 5. For larger numbers, approximates them as a square root, then a cube root, then a fourth root, and so on, then as a power tower, and then as a tetration of some number to a whole height. Supports non-whole numbers by approximating them as fractions.

PsiDashNotation

Uses PsiCubed2's "lexiographic ordering" as described here. In summary, this notation starts with exponential expressions with E, then tetrational with F, then pentational with G, then (though this usually doesn't come up) hexational with H, but after the first entry (which represents the logarithm/super-logarithm/penta-logarithm) there are entries after dashes that each add accuracy to the approximation. For example, in an E4-x expression, that x is the digits of the mantissa in n*10^4, and in an F8-x expression, that x is whatever's at the top of the power tower of 8 tens that represents the given value. This notation obeys the rule that chopping off characters from the end always produces less accurate approximations, which means each digit has more precedence than all the digits afterwards: for example, anything of the form F2-45-42..., no matter what comes after that 2, is greater than anything of the form F2-45-41...

PrestigeLayerNotation

Writes numbers based on a system of infinite layers of prestige, where each layer requires a certain amount of the previous layer and is gained at some root of the previous layer. For example, if root is 3 and requirement is 1e12, then it takes 1e12 of one layer's currency to get 1 of the next layer's currency, and multiplying the amount of one layer by X multiplies the amount of the next layer by X^(1/3).

This notation also has some public methods:

IncreasingOperatorNotation

Writes numbers using increasingly powerful operators: first addition, then multiplication, then exponentiation with a fixed top (i.e. root-style exponentiation), then exponentiation with a fixed bottom (logarithm-style), then tetration with a fixed top (super-root), then tetration with a fixed bottom (super-logarithm). Once too many of one operator is used but before it gets high enough to switch to the next, it starts showing how many times that operator is applied. Smaller numbers with the operators applied to them are themselves written in this notation, allowing for nesting parameters.

PolygonalNotation

Abbreviates numbers in terms of polygonal numbers (triangular numbers by default, but the amount of sides can be changed). For example, 10 is the 4th triangular number, so it's written as △4. △△ represents the amount of times △ is applied to 2, so △△10 means △(△(△(...△2))) with 10 △'s. Similarly, △△△ represents the amount of times △△ is applied to 2, so △△△5 means △△(△△(△△(△△(△△(2))))).

DoubleFactorialsNotation

A Myriad-like notation that abbreviates numbers in terms of powers of double factorials (as in 3!! = (3!)! = 720) and a coefficient. Numbers below 720 are just written as normal, then a factor of 3!! is introduced, so 1080 would be 1.5 * 3!!. Above 720^2, powers of 3!! are written as, well, powers of 3!!, so 1,000,000 would be around 1.929 * 3!!^2. The highest double factorial is included first, so powers of 4!! start being included, then 5!!, and so on; for example, 10^^4 is written as 5!! * 6!!^2 * 7!!^9 * 8!!^7 * 9!!^4 * 10!!^4 * 11!!^7 * 12!!^2. Once the double factorial number gets too high, the entire thing is wrapped in a single factorial, such as (12!!^5 * 13!!^7)!, then multiple factorials, then the number of factorials gets written out, eventually in this notation as well.

GridNotation

Uses a grid of empty and filled squares to represent numbers. Each row is written in binary, where empty squares are 0s and filled squares are 1s. The first row represents the number itself. The second row represents how many extra squares the first row should have before the last ones (the last ones are what's shown) - in other words, whatever number n is in the second row means the first row is multiplied by 2^n. The third row shows the amount of extra squares that should be in the second row, and so on. Negative numbers have an empty diamond in front of the first row, and such a diamond can also be in front of the second row (so the exponent of the 2^n is negative) for small numbers. For tetrational numbers, there may even be a second plane: the second plane's number is the amount of extra rows that the first plane should have before the last ones (the last ones are what's shown).

PolynomialNotation

Writes numbers in the form of a polynomial-ish expression, with x having a certain value. For example, if x is 10, then 346 is written as 3x^2 + 4x + 6.

Notations added in v1.1

MultibaseLogarithmNotation

Similar to LogarithmNotation, but each iteration takes multiple logarithms of different bases.

MultibaseMultiLogarithmNotation

Similar to MultiLogarithmNotation, but each iteration takes multiple logarithms of different bases.

PentaScientificNotation

Hyperscientific notation, but with pentation instead of tetration. Abbreviates 9 as "9G0", 10^10^10 as "3G1", and 10^^10,000,000,000 as "2G2" (though that last one is too big for this library).

PentaScientificIterationsNotation

This notation performs penta-scientific notation a certain number of times. 1 iteration means the number is in the form AGB (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form AGBGC, and so on.

PentaLogarithmNotation

Abbreviates numbers in terms of their pentational logarithm, so 10 is "G1" and 10^^10^^10 is "G3". Uses the linear approximations of tetration and pentation.

MultiPentaLogarithmNotation

A variant of penta-logarithm notation that uses a different amount of penta-logarithm iterations depending on how large the number is.

PentaRootNotation

Abbreviates numbers in terms of their pentational root; this is the square penta-root by default, so e8.0723e153 is 4↑↑↑2 and eee2.069e36,305 is 6↑↑↑2.

MultiPentaRootNotation

A variant of penta-root notation that uses a different amount of penta-root iterations depending on how large the number is.

IncreasingPentaRootNotation

A variant of penta-root notation that uses a different penta-root height depending on how large the number is.

WeakHyperscientificNotation

Scientific notation, but with "weak tetration" instead of exponentiation, where weak tetration is repeated exponentiation but evaluated bottom-to-top instead of top-to-bottom. xfy = (base↓↓y)^x, where base↓↓y = (((base^base)^base)^base...)^base = base^base^(y - 1).

WeakHyperscientificIterationsNotation

This notation performs weak hyperscientific notation a certain number of times. 1 iteration means the number is in the form AfB (where A and B are abbreviated using the innerNotation), 2 iterations means the number is in the form AfBfC, and so on.

IncreasingFunctionNotation

Takes any strictly increasing Decimal => Decimal function (preferrably one whose outputs are larger than its inputs) and uses Decimal.increasingInverse to create a Logarithm-style notation using it. For example, if the function is (v => v.pow(6)), then 729 would be written as f(3).

IncreasingFunctionScientificNotation

Takes an increasing function that takes multiple Decimals as input and returns a Decimal, and uses Decimal.increasingInverse to create a Scientific-style notation using it. The last argument is considered the highest priority argument to increment, like how the exponent is higher-priority than the mantissa in regular scientific notation.

IncreasingFunctionProductNotation

Uses three increasing functions to create a Double Factorials-style notation: numbers are expressed as a series of terms, where each term is a whole number run through the first function, then raised to some power (or whatever the second function does), and the terms are multiplied together (or whatever the third function does).

FastGrowingHierarchyNotation

A notation that abbreviates numbers using the Fast-Growing Hierarchy, a simple system of functions: f0(n) = n + 1, f1(n) is f0(f0(f0(f0...(n)))) with n f0's, f2(n) is f1(f1(f1(f1...(n)))) with n f1's, and so on, with each function being a repeated version of the previous one. The Fast-Growing Hierarchy functions have a similar growth rate to the hyperoperators: f1 multiplies, f2 is exponential, f3 is tetrational, f4 is pentational, and so on. This notation only goes up to f3.

OmegaMetaZeroNotation

Writes numbers as the layers seen in VeproGames's "Omega Meta Zero". Sort of like a mixed radix base, but with Greek letters, alchemical planet symbols, exponent-styled towers of symbols, and more instead of digits and exponents. This notation would be too complicated to explain all at once, so see the info on the parameters to understand each step of the process. (Unless otherwise stated, whenever a parameter that's an array where each entry corresponds to a set of symbols is given less entries than the amount of sets of symbols, the unfilled entries are set to be the same as the last entry that was provided.)

Part 3: Extra Functions

Those of you who have already tried the preset demonstration page and read Part 1 of this documentation may have noticed that the last box on that page, the one that gives a physical description of the number in question, wasn't listed among the presets. That's because that box isn't actually using a preset: it's using one of the extra functions provided by Eternal Notations that isn't a notation. Eternal Notations has many utility functions that it uses in the process of many notations, and I decided to make some of those functions public because they could be useful by themselves. The things listed in this box are all functions with parameters, so I'm not going to bother with the separate text color stuff in this part. Like the notation constructors, any argument that requires a Decimal will accept any DecimalSource, but if a function returns a Decimal then that's definitely a Decimal. For functions with only a few arguments I'll write them out in the parentheses next to the function, but if a function has too many arguments then I'm just going to put "...args" in those parentheses - either way, the arguments will still be listed below the function. Here is the list of Eternal Notations's extra available functions:

Added in v1.0

Added in v1.1

Credits

(In this section, "I", "me", etc. refer to MathCookie, the creator of Eternal Notations)

Most of the code in this library was written by me, with a few exceptions:

Aside from that code, though, pretty much all the rest of the code was written by me, so unlike AD Notations I don't have dozens of coders to thank. Instead, this is where I'll note who came up with each of the notations that became Eternal Notations's presets. (Many of these, even if credited to others here, were extended to tetrational numbers by me. If one preset was inspired by another, then since the original is already listed under its creator, the spinoff will be listed under the person who came up with the change, not necessarily the creator of the original. Standard variants are listed based on who chose the prefixes for that variant; separate credit is given to the original list that all variants derived their prefixes from.)