/* eslint-disable @typescript-eslint/no-this-alias */
/* eslint-disable @typescript-eslint/no-loss-of-precision */
import { LRUCache } from "../lib/lru-cache";

export type CompareResult = -1 | 0 | 1;

const MAX_SIGNIFICANT_DIGITS = 17; //Maximum number of digits of precision to assume in Number

const EXP_LIMIT = 9e15; //If we're ABOVE this value, increase a layer. (9e15 is close to the largest integer that can fit in a Number.)

const LAYER_DOWN: number = Math.log10(9e15);

const FIRST_NEG_LAYER = 1 / 9e15; //At layer 0, smaller non-zero numbers than this become layer 1 numbers with negative mag. After that the pattern continues as normal.

const NUMBER_EXP_MAX = 308; //The largest exponent that can appear in a Number, though not all mantissas are valid here.

const NUMBER_EXP_MIN = -324; //The smallest exponent that can appear in a Number, though not all mantissas are valid here.

const MAX_ES_IN_A_ROW = 5; //For default toString behaviour, when to swap from eee... to (e^n) syntax.

const DEFAULT_FROM_STRING_CACHE_SIZE = (1 << 10) - 1; // The default size of the LRU cache used to cache Decimal.fromString.

const IGNORE_COMMAS = true;
const COMMAS_ARE_DECIMAL_POINTS = false;

const powerOf10 = (function () {
    // We need this lookup table because Math.pow(10, exponent)
    // when exponent's absolute value is large is slightly inaccurate.
    // You can fix it with the power of math... or just make a lookup table.
    // Faster AND simpler
    const powersOf10: number[] = [];

    for (let i = NUMBER_EXP_MIN + 1; i <= NUMBER_EXP_MAX; i++) {
        powersOf10.push(Number("1e" + i));
    }

    const indexOf0InPowersOf10 = 323;
    return function (power: number) {
        return powersOf10[power + indexOf0InPowersOf10];
    };
})();

//tetration/slog to real height stuff
//background info and tables of values for critical functions taken here: https://github.com/Patashu/break_eternity.js/issues/22
const critical_headers = [2, Math.E, 3, 4, 5, 6, 7, 8, 9, 10];
const critical_tetr_values = [
    [
        // Base 2 (using http://myweb.astate.edu/wpaulsen/tetcalc/tetcalc.html )
        1, 1.0891180521811202527, 1.1789767925673958433, 1.2701455431742086633,
        1.3632090180450091941, 1.4587818160364217007, 1.5575237916251418333, 1.6601571006859253673,
        1.7674858188369780435, 1.8804192098842727359, 2
    ],
    [
        // Base E (using http://myweb.astate.edu/wpaulsen/tetcalc/tetcalc.html )
        1, //0.0
        1.1121114330934078681, //0.1
        1.2310389249316089299, //0.2
        1.3583836963111376089, //0.3
        1.4960519303993531879, //0.4
        1.646354233751194581, //0.5
        1.8121385357018724464, //0.6
        1.9969713246183068478, //0.7
        2.205389554552754433, //0.8
        2.4432574483385252544, //0.9
        Math.E //1.0
    ],
    [
        // Base 3
        1, 1.1187738849693603, 1.2464963939368214, 1.38527004705667, 1.5376664685821402,
        1.7068895236551784, 1.897001227148399, 2.1132403089001035, 2.362480153784171,
        2.6539010333870774, 3
    ],
    [
        // Base 4
        1, 1.1367350847096405, 1.2889510672956703, 1.4606478703324786, 1.6570295196661111,
        1.8850062585672889, 2.1539465047453485, 2.476829779693097, 2.872061932789197,
        3.3664204535587183, 4
    ],
    [
        // Base 5
        1, 1.1494592900767588, 1.319708228183931, 1.5166291280087583, 1.748171114438024,
        2.0253263297298045, 2.3636668498288547, 2.7858359149579424, 3.3257226212448145,
        4.035730287722532, 5
    ],
    [
        // Base 6
        1, 1.159225940787673, 1.343712473580932, 1.5611293155111927, 1.8221199554561318,
        2.14183924486326, 2.542468319282638, 3.0574682501653316, 3.7390572020926873,
        4.6719550537360774, 6
    ],
    [
        // Base 7
        1, 1.1670905356972596, 1.3632807444991446, 1.5979222279405536, 1.8842640123816674,
        2.2416069644878687, 2.69893426559423, 3.3012632110403577, 4.121250340630164,
        5.281493033448316, 7
    ],
    [
        // Base 8
        1, 1.1736630594087796, 1.379783782386201, 1.6292821855668218, 1.9378971836180754,
        2.3289975651071977, 2.8384347394720835, 3.5232708454565906, 4.478242031114584,
        5.868592169644505, 8
    ],
    [
        // Base 9
        1, 1.1793017514670474, 1.394054150657457, 1.65664127441059, 1.985170999970283,
        2.4069682290577457, 2.9647310119960752, 3.7278665320924946, 4.814462547283592,
        6.436522247411611, 9
    ],
    [
        // Base 10 (using http://myweb.astate.edu/wpaulsen/tetcalc/tetcalc.html )
        1, 1.1840100246247336579, 1.4061375836156954169, 1.6802272208863963918,
        2.026757028388618927, 2.477005606344964758, 3.0805252717554819987, 3.9191964192627283911,
        5.135152840833186423, 6.9899611795347148455, 10
    ]
];
const critical_slog_values = [
    [
        // Base 2
        -1, -0.9194161097107025, -0.8335625019330468, -0.7425599821143978, -0.6466611521029437,
        -0.5462617907227869, -0.4419033816638769, -0.3342645487554494, -0.224140440909962,
        -0.11241087890006762, 0
    ],
    [
        // Base E
        -1, //0.0
        -0.90603157029014, //0.1
        -0.80786507256596, //0.2
        -0.7064666939634, //0.3
        -0.60294836853664, //0.4
        -0.49849837513117, //0.5
        -0.39430303318768, //0.6
        -0.29147201034755, //0.7
        -0.19097820800866, //0.8
        -0.09361896280296, //0.9
        0 //1.0
    ],
    [
        // Base 3
        -1, -0.9021579584316141, -0.8005762598234203, -0.6964780623319391, -0.5911906810998454,
        -0.486050182576545, -0.3823089430815083, -0.28106046722897615, -0.1831906535795894,
        -0.08935809204418144, 0
    ],
    [
        // Base 4
        -1, -0.8917227442365535, -0.781258746326964, -0.6705130326902455, -0.5612813129406509,
        -0.4551067709033134, -0.35319256652135966, -0.2563741554088552, -0.1651412821106526,
        -0.0796919581982668, 0
    ],
    [
        // Base 5
        -1, -0.8843387974366064, -0.7678744063886243, -0.6529563724510552, -0.5415870994657841,
        -0.4352842206588936, -0.33504449124791424, -0.24138853420685147, -0.15445285440944467,
        -0.07409659641336663, 0
    ],
    [
        // Base 6
        -1, -0.8786709358426346, -0.7577735191184886, -0.6399546189952064, -0.527284921869926,
        -0.4211627631006314, -0.3223479611761232, -0.23107655627789858, -0.1472057700818259,
        -0.07035171210706326, 0
    ],
    [
        // Base 7
        -1, -0.8740862815291583, -0.7497032990976209, -0.6297119746181752, -0.5161838335958787,
        -0.41036238255751956, -0.31277212146489963, -0.2233976621705518, -0.1418697367979619,
        -0.06762117662323441, 0
    ],
    [
        // Base 8
        -1, -0.8702632331800649, -0.7430366914122081, -0.6213373075161548, -0.5072025698095242,
        -0.40171437727184167, -0.30517930701410456, -0.21736343968190863, -0.137710238299109,
        -0.06550774483471955, 0
    ],
    [
        // Base 9
        -1, -0.8670016295947213, -0.7373984232432306, -0.6143173985094293, -0.49973884395492807,
        -0.394584953527678, -0.2989649949848695, -0.21245647317021688, -0.13434688362382652,
        -0.0638072667348083, 0
    ],
    [
        // Base 10
        -1, -0.8641642839543857, -0.732534623168535, -0.6083127477059322, -0.4934049257184696,
        -0.3885773075899922, -0.29376029055315767, -0.2083678561173622, -0.13155653399373268,
        -0.062401588652553186, 0
    ]
];

let D = function D(value: DecimalSource): Readonly<Decimal> {
    return Decimal.fromValue_noAlloc(value);
};

let FC = function (sign: number, layer: number, mag: number) {
    return Decimal.fromComponents(sign, layer, mag);
};

let FC_NN = function FC_NN(sign: number, layer: number, mag: number) {
    return Decimal.fromComponents_noNormalize(sign, layer, mag);
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
let ME = function ME(mantissa: number, exponent: number) {
    return Decimal.fromMantissaExponent(mantissa, exponent);
};

// eslint-disable-next-line @typescript-eslint/no-unused-vars
let ME_NN = function ME_NN(mantissa: number, exponent: number) {
    return Decimal.fromMantissaExponent_noNormalize(mantissa, exponent);
};

const decimalPlaces = function decimalPlaces(value: number, places: number): number {
    const len = places + 1;
    const numDigits = Math.ceil(Math.log10(Math.abs(value)));
    const rounded =
        Math.round(value * Math.pow(10, len - numDigits)) * Math.pow(10, numDigits - len);
    return parseFloat(rounded.toFixed(Math.max(len - numDigits, 0)));
};

const f_maglog10 = function (n: number) {
    return Math.sign(n) * Math.log10(Math.abs(n));
};

//from HyperCalc source code
const f_gamma = function (n: number) {
    if (!isFinite(n)) {
        return n;
    }
    if (n < -50) {
        if (n === Math.trunc(n)) {
            return Number.NEGATIVE_INFINITY;
        }
        return 0;
    }

    let scal1 = 1;
    while (n < 10) {
        scal1 = scal1 * n;
        ++n;
    }

    n -= 1;
    let l = 0.9189385332046727; //0.5*Math.log(2*Math.PI)
    l = l + (n + 0.5) * Math.log(n);
    l = l - n;
    const n2 = n * n;
    let np = n;
    l = l + 1 / (12 * np);
    np = np * n2;
    l = l + 1 / (360 * np);
    np = np * n2;
    l = l + 1 / (1260 * np);
    np = np * n2;
    l = l + 1 / (1680 * np);
    np = np * n2;
    l = l + 1 / (1188 * np);
    np = np * n2;
    l = l + 691 / (360360 * np);
    np = np * n2;
    l = l + 7 / (1092 * np);
    np = np * n2;
    l = l + 3617 / (122400 * np);

    return Math.exp(l) / scal1;
};

const _twopi = 6.2831853071795864769252842; // 2*pi
const _EXPN1 = 0.36787944117144232159553; // exp(-1)
const OMEGA = 0.56714329040978387299997; // W(1, 0)
//from https://math.stackexchange.com/a/465183
// The evaluation can become inaccurate very close to the branch point
const f_lambertw = function (z: number, tol = 1e-10): number {
    let w;
    let wn;

    if (!Number.isFinite(z)) {
        return z;
    }
    if (z === 0) {
        return z;
    }
    if (z === 1) {
        return OMEGA;
    }

    if (z < 10) {
        w = 0;
    } else {
        w = Math.log(z) - Math.log(Math.log(z));
    }

    for (let i = 0; i < 100; ++i) {
        wn = (z * Math.exp(-w) + w * w) / (w + 1);
        if (Math.abs(wn - w) < tol * Math.abs(wn)) {
            return wn;
        } else {
            w = wn;
        }
    }

    throw Error(`Iteration failed to converge: ${z.toString()}`);
    //return Number.NaN;
};

//from https://github.com/scipy/scipy/blob/8dba340293fe20e62e173bdf2c10ae208286692f/scipy/special/lambertw.pxd
// The evaluation can become inaccurate very close to the branch point
// at ``-1/e``. In some corner cases, `lambertw` might currently
// fail to converge, or can end up on the wrong branch.
function d_lambertw(z: Decimal, tol = 1e-10): Decimal {
    let w;
    let ew, wewz, wn;

    if (!Number.isFinite(z.mag)) {
        return z;
    }
    if (z.eq(Decimal.dZero)) {
        return z;
    }
    if (z.eq(Decimal.dOne)) {
        //Split out this case because the asymptotic series blows up
        return Decimal.fromNumber(OMEGA);
    }

    //Get an initial guess for Halley's method
    w = Decimal.ln(z);

    //Halley's method; see 5.9 in [1]

    for (let i = 0; i < 100; ++i) {
        ew = w.neg().exp();
        wewz = w.sub(z.mul(ew));
        wn = w.sub(wewz.div(w.add(1).sub(w.add(2).mul(wewz).div(Decimal.mul(2, w).add(2)))));
        if (Decimal.abs(wn.sub(w)).lt(Decimal.abs(wn).mul(tol))) {
            return wn;
        } else {
            w = wn;
        }
    }

    throw Error(`Iteration failed to converge: ${z.toString()}`);
    //return Decimal.dNaN;
}

export type DecimalSource = Decimal | number | string;

/**
 * The Decimal's value is simply mantissa * 10^exponent.
 */
export default class Decimal {
    public static dZero: Decimal;
    public static dOne: Decimal;
    public static dNegOne: Decimal;
    public static dTwo: Decimal;
    public static dTen: Decimal;
    public static dNaN: Decimal;
    public static dInf: Decimal;
    public static dNegInf: Decimal;
    public static dNumberMax: Decimal;
    public static dNumberMin: Decimal;

    private static fromStringCache = new LRUCache<string, Decimal>(DEFAULT_FROM_STRING_CACHE_SIZE);

    public sign = 0;
    public mag = 0;
    public layer = 0;

    constructor(value?: DecimalSource) {
        if (value instanceof Decimal) {
            this.fromDecimal(value);
        } else if (typeof value === "number") {
            this.fromNumber(value);
        } else if (typeof value === "string") {
            this.fromString(value);
        }
    }

    get m(): number {
        if (this.sign === 0) {
            return 0;
        } else if (this.layer === 0) {
            const exp = Math.floor(Math.log10(this.mag));
            //handle special case 5e-324
            let man;
            if (this.mag === 5e-324) {
                man = 5;
            } else {
                man = this.mag / powerOf10(exp);
            }
            return this.sign * man;
        } else if (this.layer === 1) {
            const residue = this.mag - Math.floor(this.mag);
            return this.sign * Math.pow(10, residue);
        } else {
            //mantissa stops being relevant past 1e9e15 / ee15.954
            return this.sign;
        }
    }

    set m(value: number) {
        if (this.layer <= 2) {
            this.fromMantissaExponent(value, this.e);
        } else {
            //don't even pretend mantissa is meaningful
            this.sign = Math.sign(value);
            if (this.sign === 0) {
                this.layer = 0;
                this.exponent = 0;
            }
        }
    }

    get e(): number {
        if (this.sign === 0) {
            return 0;
        } else if (this.layer === 0) {
            return Math.floor(Math.log10(this.mag));
        } else if (this.layer === 1) {
            return Math.floor(this.mag);
        } else if (this.layer === 2) {
            return Math.floor(Math.sign(this.mag) * Math.pow(10, Math.abs(this.mag)));
        } else {
            return this.mag * Number.POSITIVE_INFINITY;
        }
    }
    set e(value: number) {
        this.fromMantissaExponent(this.m, value);
    }

    get s(): number {
        return this.sign;
    }
    set s(value: number) {
        if (value === 0) {
            this.sign = 0;
            this.layer = 0;
            this.mag = 0;
        } else {
            this.sign = value;
        }
    }

    // Object.defineProperty(Decimal.prototype, "mantissa", {
    get mantissa(): number {
        return this.m;
    }

    set mantissa(value: number) {
        this.m = value;
    }

    get exponent(): number {
        return this.e;
    }
    set exponent(value: number) {
        this.e = value;
    }

    public static fromComponents(sign: number, layer: number, mag: number): Decimal {
        return new Decimal().fromComponents(sign, layer, mag);
    }

    public static fromComponents_noNormalize(sign: number, layer: number, mag: number): Decimal {
        return new Decimal().fromComponents_noNormalize(sign, layer, mag);
    }

    public static fromMantissaExponent(mantissa: number, exponent: number): Decimal {
        return new Decimal().fromMantissaExponent(mantissa, exponent);
    }

    public static fromMantissaExponent_noNormalize(mantissa: number, exponent: number): Decimal {
        return new Decimal().fromMantissaExponent_noNormalize(mantissa, exponent);
    }

    public static fromDecimal(value: Decimal): Decimal {
        return new Decimal().fromDecimal(value);
    }

    public static fromNumber(value: number): Decimal {
        return new Decimal().fromNumber(value);
    }

    public static fromString(value: string): Decimal {
        return new Decimal().fromString(value);
    }

    public static fromValue(value: DecimalSource): Decimal {
        return new Decimal().fromValue(value);
    }

    /**
     * Converts a DecimalSource to a Decimal, without constructing a new Decimal
     * if the provided value is already a Decimal.
     *
     * As the return value could be the provided value itself, this function
     * returns a read-only Decimal to prevent accidental mutations of the value.
     * Use `new Decimal(value)` to explicitly create a writeable copy if mutation
     * is required.
     */
    public static fromValue_noAlloc(value: DecimalSource): Readonly<Decimal> {
        if (value instanceof Decimal) {
            return value;
        } else if (typeof value === "string") {
            const cached = Decimal.fromStringCache.get(value);
            if (cached !== undefined) {
                return cached;
            }
            return Decimal.fromString(value);
        } else if (typeof value === "number") {
            return Decimal.fromNumber(value);
        } else {
            // This should never happen... but some users like Prestige Tree Rewritten
            // pass undefined values in as DecimalSources, so we should handle this
            // case to not break them.
            return Decimal.dZero;
        }
    }

    public static abs(value: DecimalSource): Decimal {
        return D(value).abs();
    }

    public static neg(value: DecimalSource): Decimal {
        return D(value).neg();
    }

    public static negate(value: DecimalSource): Decimal {
        return D(value).neg();
    }

    public static negated(value: DecimalSource): Decimal {
        return D(value).neg();
    }

    public static sign(value: DecimalSource): number {
        return D(value).sign;
    }

    public static sgn(value: DecimalSource): number {
        return D(value).sign;
    }

    public static round(value: DecimalSource): Decimal {
        return D(value).round();
    }

    public static floor(value: DecimalSource): Decimal {
        return D(value).floor();
    }

    public static ceil(value: DecimalSource): Decimal {
        return D(value).ceil();
    }

    public static trunc(value: DecimalSource): Decimal {
        return D(value).trunc();
    }

    public static add(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).add(other);
    }

    public static plus(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).add(other);
    }

    public static sub(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).sub(other);
    }

    public static subtract(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).sub(other);
    }

    public static minus(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).sub(other);
    }

    public static mul(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).mul(other);
    }

    public static multiply(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).mul(other);
    }

    public static times(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).mul(other);
    }

    public static div(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).div(other);
    }

    public static divide(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).div(other);
    }

    public static recip(value: DecimalSource): Decimal {
        return D(value).recip();
    }

    public static reciprocal(value: DecimalSource): Decimal {
        return D(value).recip();
    }

    public static reciprocate(value: DecimalSource): Decimal {
        return D(value).reciprocate();
    }

    public static cmp(value: DecimalSource, other: DecimalSource): CompareResult {
        return D(value).cmp(other);
    }

    public static cmpabs(value: DecimalSource, other: DecimalSource): CompareResult {
        return D(value).cmpabs(other);
    }

    public static compare(value: DecimalSource, other: DecimalSource): CompareResult {
        return D(value).cmp(other);
    }

    public static isNaN(value: DecimalSource): boolean {
        value = D(value);
        return isNaN(value.sign) || isNaN(value.layer) || isNaN(value.mag);
    }

    public static isFinite(value: DecimalSource): boolean {
        value = D(value);
        return isFinite(value.sign) && isFinite(value.layer) && isFinite(value.mag);
    }

    public static eq(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).eq(other);
    }

    public static equals(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).eq(other);
    }

    public static neq(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).neq(other);
    }

    public static notEquals(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).notEquals(other);
    }

    public static lt(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).lt(other);
    }

    public static lte(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).lte(other);
    }

    public static gt(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).gt(other);
    }

    public static gte(value: DecimalSource, other: DecimalSource): boolean {
        return D(value).gte(other);
    }

    public static max(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).max(other);
    }

    public static min(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).min(other);
    }

    public static minabs(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).minabs(other);
    }

    public static maxabs(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).maxabs(other);
    }

    public static clamp(value: DecimalSource, min: DecimalSource, max: DecimalSource): Decimal {
        return D(value).clamp(min, max);
    }

    public static clampMin(value: DecimalSource, min: DecimalSource): Decimal {
        return D(value).clampMin(min);
    }

    public static clampMax(value: DecimalSource, max: DecimalSource): Decimal {
        return D(value).clampMax(max);
    }

    public static cmp_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): CompareResult {
        return D(value).cmp_tolerance(other, tolerance);
    }

    public static compare_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): CompareResult {
        return D(value).cmp_tolerance(other, tolerance);
    }

    public static eq_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance?: number
    ): boolean {
        return D(value).eq_tolerance(other, tolerance);
    }

    public static equals_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance?: number
    ): boolean {
        return D(value).eq_tolerance(other, tolerance);
    }

    public static neq_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).neq_tolerance(other, tolerance);
    }

    public static notEquals_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).notEquals_tolerance(other, tolerance);
    }

    public static lt_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).lt_tolerance(other, tolerance);
    }

    public static lte_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).lte_tolerance(other, tolerance);
    }

    public static gt_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).gt_tolerance(other, tolerance);
    }

    public static gte_tolerance(
        value: DecimalSource,
        other: DecimalSource,
        tolerance: number
    ): boolean {
        return D(value).gte_tolerance(other, tolerance);
    }

    public static pLog10(value: DecimalSource): Decimal {
        return D(value).pLog10();
    }

    public static absLog10(value: DecimalSource): Decimal {
        return D(value).absLog10();
    }

    public static log10(value: DecimalSource): Decimal {
        return D(value).log10();
    }

    public static log(value: DecimalSource, base: DecimalSource): Decimal {
        return D(value).log(base);
    }

    public static log2(value: DecimalSource): Decimal {
        return D(value).log2();
    }

    public static ln(value: DecimalSource): Decimal {
        return D(value).ln();
    }

    public static logarithm(value: DecimalSource, base: DecimalSource): Decimal {
        return D(value).logarithm(base);
    }

    public static pow(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).pow(other);
    }

    public static pow10(value: DecimalSource): Decimal {
        return D(value).pow10();
    }

    public static root(value: DecimalSource, other: DecimalSource): Decimal {
        return D(value).root(other);
    }

    public static factorial(value: DecimalSource, _other?: never): Decimal {
        return D(value).factorial();
    }

    public static gamma(value: DecimalSource, _other?: never): Decimal {
        return D(value).gamma();
    }

    public static lngamma(value: DecimalSource, _other?: never): Decimal {
        return D(value).lngamma();
    }

    public static exp(value: DecimalSource): Decimal {
        return D(value).exp();
    }

    public static sqr(value: DecimalSource): Decimal {
        return D(value).sqr();
    }

    public static sqrt(value: DecimalSource): Decimal {
        return D(value).sqrt();
    }

    public static cube(value: DecimalSource): Decimal {
        return D(value).cube();
    }

    public static cbrt(value: DecimalSource): Decimal {
        return D(value).cbrt();
    }

    public static tetrate(
        value: DecimalSource,
        height = 2,
        payload: DecimalSource = FC_NN(1, 0, 1)
    ): Decimal {
        return D(value).tetrate(height, payload);
    }

    public static iteratedexp(value: DecimalSource, height = 2, payload = FC_NN(1, 0, 1)): Decimal {
        return D(value).iteratedexp(height, payload);
    }

    public static iteratedlog(value: DecimalSource, base: DecimalSource = 10, times = 1): Decimal {
        return D(value).iteratedlog(base, times);
    }

    public static layeradd10(value: DecimalSource, diff: DecimalSource): Decimal {
        return D(value).layeradd10(diff);
    }

    public static layeradd(value: DecimalSource, diff: number, base: DecimalSource = 10): Decimal {
        return D(value).layeradd(diff, base);
    }

    public static slog(value: DecimalSource, base = 10): Decimal {
        return D(value).slog(base);
    }

    public static lambertw(value: DecimalSource): Decimal {
        return D(value).lambertw();
    }

    public static ssqrt(value: DecimalSource): Decimal {
        return D(value).ssqrt();
    }

    public static pentate(
        value: DecimalSource,
        height = 2,
        payload: DecimalSource = FC_NN(1, 0, 1)
    ): Decimal {
        return D(value).pentate(height, payload);
    }

    public static sin(value: DecimalSource): Decimal {
        return D(value).sin();
    }

    public static cos(value: DecimalSource): Decimal {
        return D(value).cos();
    }

    public static tan(value: DecimalSource): Decimal {
        return D(value).tan();
    }

    public static asin(value: DecimalSource): Decimal {
        return D(value).asin();
    }

    public static acos(value: DecimalSource): Decimal {
        return D(value).acos();
    }

    public static atan(value: DecimalSource): Decimal {
        return D(value).atan();
    }

    public static sinh(value: DecimalSource): Decimal {
        return D(value).sinh();
    }

    public static cosh(value: DecimalSource): Decimal {
        return D(value).cosh();
    }

    public static tanh(value: DecimalSource): Decimal {
        return D(value).tanh();
    }

    public static asinh(value: DecimalSource): Decimal {
        return D(value).asinh();
    }

    public static acosh(value: DecimalSource): Decimal {
        return D(value).acosh();
    }

    public static atanh(value: DecimalSource): Decimal {
        return D(value).atanh();
    }

    /**
     * If you're willing to spend 'resourcesAvailable' and want to buy something
     * with exponentially increasing cost each purchase (start at priceStart,
     * multiply by priceRatio, already own currentOwned), how much of it can you buy?
     * Adapted from Trimps source code.
     */

    public static affordGeometricSeries(
        resourcesAvailable: DecimalSource,
        priceStart: DecimalSource,
        priceRatio: DecimalSource,
        currentOwned: DecimalSource
    ): Decimal {
        return this.affordGeometricSeries_core(
            D(resourcesAvailable),
            D(priceStart),
            D(priceRatio),
            currentOwned
        );
    }
    /**
     * How much resource would it cost to buy (numItems) items if you already have currentOwned,
     * the initial price is priceStart and it multiplies by priceRatio each purchase?
     */

    public static sumGeometricSeries(
        numItems: DecimalSource,
        priceStart: DecimalSource,
        priceRatio: DecimalSource,
        currentOwned: DecimalSource
    ): Decimal {
        return this.sumGeometricSeries_core(numItems, D(priceStart), D(priceRatio), currentOwned);
    }
    /**
     * If you're willing to spend 'resourcesAvailable' and want to buy something with additively
     * increasing cost each purchase (start at priceStart, add by priceAdd, already own currentOwned),
     * how much of it can you buy?
     */

    public static affordArithmeticSeries(
        resourcesAvailable: DecimalSource,
        priceStart: DecimalSource,
        priceAdd: DecimalSource,
        currentOwned: DecimalSource
    ): Decimal {
        return this.affordArithmeticSeries_core(
            D(resourcesAvailable),
            D(priceStart),
            D(priceAdd),
            D(currentOwned)
        );
    }
    /**
     * How much resource would it cost to buy (numItems) items if you already have currentOwned,
     * the initial price is priceStart and it adds priceAdd each purchase?
     * Adapted from http://www.mathwords.com/a/arithmetic_series.htm
     */

    public static sumArithmeticSeries(
        numItems: DecimalSource,
        priceStart: DecimalSource,
        priceAdd: DecimalSource,
        currentOwned: DecimalSource
    ): Decimal {
        return this.sumArithmeticSeries_core(
            D(numItems),
            D(priceStart),
            D(priceAdd),
            D(currentOwned)
        );
    }
    /**
     * When comparing two purchases that cost (resource) and increase your resource/sec by (deltaRpS),
     * the lowest efficiency score is the better one to purchase.
     * From Frozen Cookies:
     * http://cookieclicker.wikia.com/wiki/Frozen_Cookies_(JavaScript_Add-on)#Efficiency.3F_What.27s_that.3F
     */

    public static efficiencyOfPurchase(
        cost: DecimalSource,
        currentRpS: DecimalSource,
        deltaRpS: DecimalSource
    ): Decimal {
        return this.efficiencyOfPurchase_core(D(cost), D(currentRpS), D(deltaRpS));
    }

    public static randomDecimalForTesting(maxLayers: number): Decimal {
        // NOTE: This doesn't follow any kind of sane random distribution, so use this for testing purposes only.
        //5% of the time, return 0
        if (Math.random() * 20 < 1) {
            return FC_NN(0, 0, 0);
        }

        const randomsign = Math.random() > 0.5 ? 1 : -1;

        //5% of the time, return 1 or -1
        if (Math.random() * 20 < 1) {
            return FC_NN(randomsign, 0, 1);
        }

        //pick a random layer
        const layer = Math.floor(Math.random() * (maxLayers + 1));

        let randomexp = layer === 0 ? Math.random() * 616 - 308 : Math.random() * 16;
        //10% of the time, make it a simple power of 10
        if (Math.random() > 0.9) {
            randomexp = Math.trunc(randomexp);
        }
        let randommag = Math.pow(10, randomexp);
        //10% of the time, trunc mag
        if (Math.random() > 0.9) {
            randommag = Math.trunc(randommag);
        }
        return FC(randomsign, layer, randommag);
    }

    public static affordGeometricSeries_core(
        resourcesAvailable: Decimal,
        priceStart: Decimal,
        priceRatio: Decimal,
        currentOwned: DecimalSource
    ): Decimal {
        const actualStart = priceStart.mul(priceRatio.pow(currentOwned));
        return Decimal.floor(
            resourcesAvailable
                .div(actualStart)
                .mul(priceRatio.sub(1))
                .add(1)
                .log10()
                .div(priceRatio.log10())
        );
    }

    public static sumGeometricSeries_core(
        numItems: DecimalSource,
        priceStart: Decimal,
        priceRatio: Decimal,
        currentOwned: DecimalSource
    ): Decimal {
        return priceStart
            .mul(priceRatio.pow(currentOwned))
            .mul(Decimal.sub(1, priceRatio.pow(numItems)))
            .div(Decimal.sub(1, priceRatio));
    }

    public static affordArithmeticSeries_core(
        resourcesAvailable: Decimal,
        priceStart: Decimal,
        priceAdd: Decimal,
        currentOwned: Decimal
    ): Decimal {
        // n = (-(a-d/2) + sqrt((a-d/2)^2+2dS))/d
        // where a is actualStart, d is priceAdd and S is resourcesAvailable
        // then floor it and you're done!
        const actualStart = priceStart.add(currentOwned.mul(priceAdd));
        const b = actualStart.sub(priceAdd.div(2));
        const b2 = b.pow(2);
        return b
            .neg()
            .add(b2.add(priceAdd.mul(resourcesAvailable).mul(2)).sqrt())
            .div(priceAdd)
            .floor();
    }

    public static sumArithmeticSeries_core(
        numItems: Decimal,
        priceStart: Decimal,
        priceAdd: Decimal,
        currentOwned: Decimal
    ): Decimal {
        const actualStart = priceStart.add(currentOwned.mul(priceAdd)); // (n/2)*(2*a+(n-1)*d)

        return numItems.div(2).mul(actualStart.mul(2).plus(numItems.sub(1).mul(priceAdd)));
    }

    public static efficiencyOfPurchase_core(
        cost: Decimal,
        currentRpS: Decimal,
        deltaRpS: Decimal
    ): Decimal {
        return cost.div(currentRpS).add(cost.div(deltaRpS));
    }

    public normalize(): this {
        /*
                                                                                                            PSEUDOCODE:
                                                                                                            Whenever we are partially 0 (sign is 0 or mag and layer is 0), make it fully 0.
                                                                                                            Whenever we are at or hit layer 0, extract sign from negative mag.
                                                                                                            If layer === 0 and mag < FIRST_NEG_LAYER (1/9e15), shift to 'first negative layer' (add layer, log10 mag).
                                                                                                            While abs(mag) > EXP_LIMIT (9e15), layer += 1, mag = maglog10(mag).
                                                                                                            While abs(mag) < LAYER_DOWN (15.954) and layer > 0, layer -= 1, mag = pow(10, mag).
                                                                                                            
                                                                                                            When we're done, all of the following should be true OR one of the numbers is not IsFinite OR layer is not IsInteger (error state):
                                                                                                            Any 0 is totally zero (0, 0, 0).
                                                                                                            Anything layer 0 has mag 0 OR mag > 1/9e15 and < 9e15.
                                                                                                            Anything layer 1 or higher has abs(mag) >= 15.954 and < 9e15.
                                                                                                            We will assume in calculations that all Decimals are either erroneous or satisfy these criteria. (Otherwise: Garbage in, garbage out.)
                                                                                                            */
        if (this.sign === 0 || (this.mag === 0 && this.layer === 0)) {
            this.sign = 0;
            this.mag = 0;
            this.layer = 0;
            return this;
        }

        if (this.layer === 0 && this.mag < 0) {
            //extract sign from negative mag at layer 0
            this.mag = -this.mag;
            this.sign = -this.sign;
        }

        //Handle shifting from layer 0 to negative layers.
        if (this.layer === 0 && this.mag < FIRST_NEG_LAYER) {
            this.layer += 1;
            this.mag = Math.log10(this.mag);
            return this;
        }

        let absmag = Math.abs(this.mag);
        let signmag = Math.sign(this.mag);

        if (absmag >= EXP_LIMIT) {
            this.layer += 1;
            this.mag = signmag * Math.log10(absmag);
            return this;
        } else {
            while (absmag < LAYER_DOWN && this.layer > 0) {
                this.layer -= 1;
                if (this.layer === 0) {
                    this.mag = Math.pow(10, this.mag);
                } else {
                    this.mag = signmag * Math.pow(10, absmag);
                    absmag = Math.abs(this.mag);
                    signmag = Math.sign(this.mag);
                }
            }
            if (this.layer === 0) {
                if (this.mag < 0) {
                    //extract sign from negative mag at layer 0
                    this.mag = -this.mag;
                    this.sign = -this.sign;
                } else if (this.mag === 0) {
                    //excessive rounding can give us all zeroes
                    this.sign = 0;
                }
            }
        }

        return this;
    }

    public fromComponents(sign: number, layer: number, mag: number): this {
        this.sign = sign;
        this.layer = layer;
        this.mag = mag;

        this.normalize();
        return this;
    }

    public fromComponents_noNormalize(sign: number, layer: number, mag: number): this {
        this.sign = sign;
        this.layer = layer;
        this.mag = mag;
        return this;
    }

    public fromMantissaExponent(mantissa: number, exponent: number): this {
        this.layer = 1;
        this.sign = Math.sign(mantissa);
        mantissa = Math.abs(mantissa);
        this.mag = exponent + Math.log10(mantissa);

        this.normalize();
        return this;
    }

    public fromMantissaExponent_noNormalize(mantissa: number, exponent: number): this {
        //The idea of 'normalizing' a break_infinity.js style Decimal doesn't really apply. So just do the same thing.
        this.fromMantissaExponent(mantissa, exponent);
        return this;
    }

    public fromDecimal(value: Decimal): this {
        this.sign = value.sign;
        this.layer = value.layer;
        this.mag = value.mag;
        return this;
    }

    public fromNumber(value: number): this {
        this.mag = Math.abs(value);
        this.sign = Math.sign(value);
        this.layer = 0;
        this.normalize();
        return this;
    }

    public fromString(value: string): Decimal {
        const originalValue = value;
        const cached = Decimal.fromStringCache.get(originalValue);
        if (cached !== undefined) {
            return this.fromDecimal(cached);
        }
        if (IGNORE_COMMAS) {
            value = value.replace(",", "");
        } else if (COMMAS_ARE_DECIMAL_POINTS) {
            value = value.replace(",", ".");
        }

        //Handle x^^^y format.
        const pentationparts = value.split("^^^");
        if (pentationparts.length === 2) {
            const base = parseFloat(pentationparts[0]);
            const height = parseFloat(pentationparts[1]);
            const heightparts = pentationparts[1].split(";");
            let payload = 1;
            if (heightparts.length === 2) {
                payload = parseFloat(heightparts[1]);
                if (!isFinite(payload)) {
                    payload = 1;
                }
            }
            if (isFinite(base) && isFinite(height)) {
                const result = Decimal.pentate(base, height, payload);
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        //Handle x^^y format.
        const tetrationparts = value.split("^^");
        if (tetrationparts.length === 2) {
            const base = parseFloat(tetrationparts[0]);
            const height = parseFloat(tetrationparts[1]);
            const heightparts = tetrationparts[1].split(";");
            let payload = 1;
            if (heightparts.length === 2) {
                payload = parseFloat(heightparts[1]);
                if (!isFinite(payload)) {
                    payload = 1;
                }
            }
            if (isFinite(base) && isFinite(height)) {
                const result = Decimal.tetrate(base, height, payload);
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        //Handle x^y format.
        const powparts = value.split("^");
        if (powparts.length === 2) {
            const base = parseFloat(powparts[0]);
            const exponent = parseFloat(powparts[1]);
            if (isFinite(base) && isFinite(exponent)) {
                const result = Decimal.pow(base, exponent);
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        //Handle various cases involving it being a Big Number.
        value = value.trim().toLowerCase();

        //handle X PT Y format.
        let base;
        let height;
        let ptparts = value.split("pt");
        if (ptparts.length === 2) {
            base = 10;
            height = parseFloat(ptparts[0]);
            ptparts[1] = ptparts[1].replace("(", "");
            ptparts[1] = ptparts[1].replace(")", "");
            let payload = parseFloat(ptparts[1]);
            if (!isFinite(payload)) {
                payload = 1;
            }
            if (isFinite(base) && isFinite(height)) {
                const result = Decimal.tetrate(base, height, payload);
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        //handle XpY format (it's the same thing just with p).
        ptparts = value.split("p");
        if (ptparts.length === 2) {
            base = 10;
            height = parseFloat(ptparts[0]);
            ptparts[1] = ptparts[1].replace("(", "");
            ptparts[1] = ptparts[1].replace(")", "");
            let payload = parseFloat(ptparts[1]);
            if (!isFinite(payload)) {
                payload = 1;
            }
            if (isFinite(base) && isFinite(height)) {
                const result = Decimal.tetrate(base, height, payload);
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        const parts = value.split("e");
        const ecount = parts.length - 1;

        //Handle numbers that are exactly floats (0 or 1 es).
        if (ecount === 0) {
            const numberAttempt = parseFloat(value);
            if (isFinite(numberAttempt)) {
                this.fromNumber(numberAttempt);
                if (Decimal.fromStringCache.size >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        } else if (ecount === 1) {
            //Very small numbers ("2e-3000" and so on) may look like valid floats but round to 0.
            const numberAttempt = parseFloat(value);
            if (isFinite(numberAttempt) && numberAttempt !== 0) {
                this.fromNumber(numberAttempt);
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            }
        }

        //Handle new (e^N)X format.
        const newparts = value.split("e^");
        if (newparts.length === 2) {
            this.sign = 1;
            if (newparts[0].charAt(0) == "-") {
                this.sign = -1;
            }
            let layerstring = "";
            for (let i = 0; i < newparts[1].length; ++i) {
                const chrcode = newparts[1].charCodeAt(i);
                if ((chrcode >= 43 && chrcode <= 57) || chrcode === 101) {
                    //is "0" to "9" or "+" or "-" or "." or "e" (or "," or "/")
                    layerstring += newparts[1].charAt(i);
                } //we found the end of the layer count
                else {
                    this.layer = parseFloat(layerstring);
                    this.mag = parseFloat(newparts[1].substr(i + 1));
                    this.normalize();
                    if (Decimal.fromStringCache.maxSize >= 1) {
                        Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                    }
                    return this;
                }
            }
        }

        if (ecount < 1) {
            this.sign = 0;
            this.layer = 0;
            this.mag = 0;
            if (Decimal.fromStringCache.maxSize >= 1) {
                Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
            }
            return this;
        }
        const mantissa = parseFloat(parts[0]);
        if (mantissa === 0) {
            this.sign = 0;
            this.layer = 0;
            this.mag = 0;
            if (Decimal.fromStringCache.maxSize >= 1) {
                Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
            }
            return this;
        }
        let exponent = parseFloat(parts[parts.length - 1]);
        //handle numbers like AeBeC and AeeeeBeC
        if (ecount >= 2) {
            const me = parseFloat(parts[parts.length - 2]);
            if (isFinite(me)) {
                exponent *= Math.sign(me);
                exponent += f_maglog10(me);
            }
        }

        //Handle numbers written like eee... (N es) X
        if (!isFinite(mantissa)) {
            this.sign = parts[0] === "-" ? -1 : 1;
            this.layer = ecount;
            this.mag = exponent;
        }
        //Handle numbers written like XeY
        else if (ecount === 1) {
            this.sign = Math.sign(mantissa);
            this.layer = 1;
            //Example: 2e10 is equal to 10^log10(2e10) which is equal to 10^(10+log10(2))
            this.mag = exponent + Math.log10(Math.abs(mantissa));
        }
        //Handle numbers written like Xeee... (N es) Y
        else {
            this.sign = Math.sign(mantissa);
            this.layer = ecount;
            if (ecount === 2) {
                const result = Decimal.mul(FC(1, 2, exponent), D(mantissa));
                this.sign = result.sign;
                this.layer = result.layer;
                this.mag = result.mag;
                if (Decimal.fromStringCache.maxSize >= 1) {
                    Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
                }
                return this;
            } else {
                //at eee and above, mantissa is too small to be recognizable!
                this.mag = exponent;
            }
        }

        this.normalize();
        if (Decimal.fromStringCache.maxSize >= 1) {
            Decimal.fromStringCache.set(originalValue, Decimal.fromDecimal(this));
        }
        return this;
    }

    public fromValue(value: DecimalSource): Decimal {
        if (value instanceof Decimal) {
            return this.fromDecimal(value);
        }

        if (typeof value === "number") {
            return this.fromNumber(value);
        }

        if (typeof value === "string") {
            return this.fromString(value);
        }

        this.sign = 0;
        this.layer = 0;
        this.mag = 0;
        return this;
    }

    public toNumber(): number {
        if (!Number.isFinite(this.layer)) {
            return Number.NaN;
        }
        if (this.layer === 0) {
            return this.sign * this.mag;
        } else if (this.layer === 1) {
            return this.sign * Math.pow(10, this.mag);
        } //overflow for any normalized Decimal
        else {
            return this.mag > 0
                ? this.sign > 0
                    ? Number.POSITIVE_INFINITY
                    : Number.NEGATIVE_INFINITY
                : 0;
        }
    }

    public mantissaWithDecimalPlaces(places: number): number {
        // https://stackoverflow.com/a/37425022
        if (isNaN(this.m)) {
            return Number.NaN;
        }

        if (this.m === 0) {
            return 0;
        }

        return decimalPlaces(this.m, places);
    }

    public magnitudeWithDecimalPlaces(places: number): number {
        // https://stackoverflow.com/a/37425022
        if (isNaN(this.mag)) {
            return Number.NaN;
        }

        if (this.mag === 0) {
            return 0;
        }

        return decimalPlaces(this.mag, places);
    }

    public toString(): string {
        if (isNaN(this.layer) || isNaN(this.sign) || isNaN(this.mag)) {
            return "NaN";
        }
        if (this.mag === Number.POSITIVE_INFINITY || this.layer === Number.POSITIVE_INFINITY) {
            return this.sign === 1 ? "Infinity" : "-Infinity";
        }

        if (this.layer === 0) {
            if ((this.mag < 1e21 && this.mag > 1e-7) || this.mag === 0) {
                return (this.sign * this.mag).toString();
            }
            return this.m + "e" + this.e;
        } else if (this.layer === 1) {
            return this.m + "e" + this.e;
        } else {
            //layer 2+
            if (this.layer <= MAX_ES_IN_A_ROW) {
                return (this.sign === -1 ? "-" : "") + "e".repeat(this.layer) + this.mag;
            } else {
                return (this.sign === -1 ? "-" : "") + "(e^" + this.layer + ")" + this.mag;
            }
        }
    }

    public toExponential(places: number): string {
        if (this.layer === 0) {
            return (this.sign * this.mag).toExponential(places);
        }
        return this.toStringWithDecimalPlaces(places);
    }

    public toFixed(places: number): string {
        if (this.layer === 0) {
            return (this.sign * this.mag).toFixed(places);
        }
        return this.toStringWithDecimalPlaces(places);
    }

    public toPrecision(places: number): string {
        if (this.e <= -7) {
            return this.toExponential(places - 1);
        }

        if (places > this.e) {
            return this.toFixed(places - this.exponent - 1);
        }

        return this.toExponential(places - 1);
    }

    public valueOf(): string {
        return this.toString();
    }

    public toJSON(): string {
        return this.toString();
    }

    public toStringWithDecimalPlaces(places: number): string {
        if (this.layer === 0) {
            if ((this.mag < 1e21 && this.mag > 1e-7) || this.mag === 0) {
                return (this.sign * this.mag).toFixed(places);
            }
            return decimalPlaces(this.m, places) + "e" + decimalPlaces(this.e, places);
        } else if (this.layer === 1) {
            return decimalPlaces(this.m, places) + "e" + decimalPlaces(this.e, places);
        } else {
            //layer 2+
            if (this.layer <= MAX_ES_IN_A_ROW) {
                return (
                    (this.sign === -1 ? "-" : "") +
                    "e".repeat(this.layer) +
                    decimalPlaces(this.mag, places)
                );
            } else {
                return (
                    (this.sign === -1 ? "-" : "") +
                    "(e^" +
                    this.layer +
                    ")" +
                    decimalPlaces(this.mag, places)
                );
            }
        }
    }

    public abs(): Decimal {
        return FC_NN(this.sign === 0 ? 0 : 1, this.layer, this.mag);
    }

    public neg(): Decimal {
        return FC_NN(-this.sign, this.layer, this.mag);
    }

    public negate(): Decimal {
        return this.neg();
    }

    public negated(): Decimal {
        return this.neg();
    }

    // public sign () {
    //     return this.sign;
    //   }

    public sgn(): number {
        return this.sign;
    }

    public round(): this | Decimal {
        if (this.mag < 0) {
            return Decimal.dZero;
        }
        if (this.layer === 0) {
            return FC(this.sign, 0, Math.round(this.mag));
        }
        return this;
    }

    public floor(): this | Decimal {
        if (this.mag < 0) {
            return Decimal.dZero;
        }
        if (this.layer === 0) {
            return FC(this.sign, 0, Math.floor(this.mag));
        }
        return this;
    }

    public ceil(): this | Decimal {
        if (this.mag < 0) {
            return Decimal.dZero;
        }
        if (this.layer === 0) {
            return FC(this.sign, 0, Math.ceil(this.mag));
        }
        return this;
    }

    public trunc(): this | Decimal {
        if (this.mag < 0) {
            return Decimal.dZero;
        }
        if (this.layer === 0) {
            return FC(this.sign, 0, Math.trunc(this.mag));
        }
        return this;
    }

    public add(value: DecimalSource): this | Decimal {
        const decimal = D(value);

        //inf/nan check
        if (!Number.isFinite(this.layer)) {
            return this;
        }
        if (!Number.isFinite(decimal.layer)) {
            return decimal;
        }

        //Special case - if one of the numbers is 0, return the other number.
        if (this.sign === 0) {
            return decimal;
        }
        if (decimal.sign === 0) {
            return this;
        }

        //Special case - Adding a number to its negation produces 0, no matter how large.
        if (
            this.sign === -decimal.sign &&
            this.layer === decimal.layer &&
            this.mag === decimal.mag
        ) {
            return FC_NN(0, 0, 0);
        }

        let a;
        let b;

        //Special case: If one of the numbers is layer 2 or higher, just take the bigger number.
        if (this.layer >= 2 || decimal.layer >= 2) {
            return this.maxabs(decimal);
        }

        if (Decimal.cmpabs(this, decimal) > 0) {
            a = this;
            b = decimal;
        } else {
            a = decimal;
            b = this;
        }

        if (a.layer === 0 && b.layer === 0) {
            return Decimal.fromNumber(a.sign * a.mag + b.sign * b.mag);
        }

        const layera = a.layer * Math.sign(a.mag);
        const layerb = b.layer * Math.sign(b.mag);

        //If one of the numbers is 2+ layers higher than the other, just take the bigger number.
        if (layera - layerb >= 2) {
            return a;
        }

        if (layera === 0 && layerb === -1) {
            if (Math.abs(b.mag - Math.log10(a.mag)) > MAX_SIGNIFICANT_DIGITS) {
                return a;
            } else {
                const magdiff = Math.pow(10, Math.log10(a.mag) - b.mag);
                const mantissa = b.sign + a.sign * magdiff;
                return FC(Math.sign(mantissa), 1, b.mag + Math.log10(Math.abs(mantissa)));
            }
        }

        if (layera === 1 && layerb === 0) {
            if (Math.abs(a.mag - Math.log10(b.mag)) > MAX_SIGNIFICANT_DIGITS) {
                return a;
            } else {
                const magdiff = Math.pow(10, a.mag - Math.log10(b.mag));
                const mantissa = b.sign + a.sign * magdiff;
                return FC(
                    Math.sign(mantissa),
                    1,
                    Math.log10(b.mag) + Math.log10(Math.abs(mantissa))
                );
            }
        }

        if (Math.abs(a.mag - b.mag) > MAX_SIGNIFICANT_DIGITS) {
            return a;
        } else {
            const magdiff = Math.pow(10, a.mag - b.mag);
            const mantissa = b.sign + a.sign * magdiff;
            return FC(Math.sign(mantissa), 1, b.mag + Math.log10(Math.abs(mantissa)));
        }

        throw Error("Bad arguments to add: " + this + ", " + value);
    }

    public plus(value: DecimalSource): Decimal {
        return this.add(value);
    }

    public sub(value: DecimalSource): Decimal {
        return this.add(D(value).neg());
    }

    public subtract(value: DecimalSource): Decimal {
        return this.sub(value);
    }

    public minus(value: DecimalSource): Decimal {
        return this.sub(value);
    }

    public mul(value: DecimalSource): Decimal {
        const decimal = D(value);

        //inf/nan check
        if (!Number.isFinite(this.layer)) {
            return this;
        }
        if (!Number.isFinite(decimal.layer)) {
            return decimal;
        }

        //Special case - if one of the numbers is 0, return 0.
        if (this.sign === 0 || decimal.sign === 0) {
            return FC_NN(0, 0, 0);
        }

        //Special case - Multiplying a number by its own reciprocal yields +/- 1, no matter how large.
        if (this.layer === decimal.layer && this.mag === -decimal.mag) {
            return FC_NN(this.sign * decimal.sign, 0, 1);
        }

        let a;
        let b;

        //Which number is bigger in terms of its multiplicative distance from 1?
        if (
            this.layer > decimal.layer ||
            (this.layer == decimal.layer && Math.abs(this.mag) > Math.abs(decimal.mag))
        ) {
            a = this;
            b = decimal;
        } else {
            a = decimal;
            b = this;
        }

        if (a.layer === 0 && b.layer === 0) {
            return Decimal.fromNumber(a.sign * b.sign * a.mag * b.mag);
        }

        //Special case: If one of the numbers is layer 3 or higher or one of the numbers is 2+ layers bigger than the other, just take the bigger number.
        if (a.layer >= 3 || a.layer - b.layer >= 2) {
            return FC(a.sign * b.sign, a.layer, a.mag);
        }

        if (a.layer === 1 && b.layer === 0) {
            return FC(a.sign * b.sign, 1, a.mag + Math.log10(b.mag));
        }

        if (a.layer === 1 && b.layer === 1) {
            return FC(a.sign * b.sign, 1, a.mag + b.mag);
        }

        if (a.layer === 2 && b.layer === 1) {
            const newmag = FC(Math.sign(a.mag), a.layer - 1, Math.abs(a.mag)).add(
                FC(Math.sign(b.mag), b.layer - 1, Math.abs(b.mag))
            );
            return FC(a.sign * b.sign, newmag.layer + 1, newmag.sign * newmag.mag);
        }

        if (a.layer === 2 && b.layer === 2) {
            const newmag = FC(Math.sign(a.mag), a.layer - 1, Math.abs(a.mag)).add(
                FC(Math.sign(b.mag), b.layer - 1, Math.abs(b.mag))
            );
            return FC(a.sign * b.sign, newmag.layer + 1, newmag.sign * newmag.mag);
        }

        throw Error("Bad arguments to mul: " + this + ", " + value);
    }

    public multiply(value: DecimalSource): Decimal {
        return this.mul(value);
    }

    public times(value: DecimalSource): Decimal {
        return this.mul(value);
    }

    public div(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.mul(decimal.recip());
    }

    public divide(value: DecimalSource): Decimal {
        return this.div(value);
    }

    public divideBy(value: DecimalSource): Decimal {
        return this.div(value);
    }

    public dividedBy(value: DecimalSource): Decimal {
        return this.div(value);
    }

    public recip(): Decimal {
        if (this.mag === 0) {
            return Decimal.dNaN;
        } else if (this.layer === 0) {
            return FC(this.sign, 0, 1 / this.mag);
        } else {
            return FC(this.sign, this.layer, -this.mag);
        }
    }

    public reciprocal(): Decimal {
        return this.recip();
    }

    public reciprocate(): Decimal {
        return this.recip();
    }

    /**
     * -1 for less than value, 0 for equals value, 1 for greater than value
     */
    public cmp(value: DecimalSource): CompareResult {
        const decimal = D(value);
        if (this.sign > decimal.sign) {
            return 1;
        }
        if (this.sign < decimal.sign) {
            return -1;
        }
        return (this.sign * this.cmpabs(value)) as CompareResult;
    }

    public cmpabs(value: DecimalSource): CompareResult {
        const decimal = D(value);
        const layera = this.mag > 0 ? this.layer : -this.layer;
        const layerb = decimal.mag > 0 ? decimal.layer : -decimal.layer;
        if (layera > layerb) {
            return 1;
        }
        if (layera < layerb) {
            return -1;
        }
        if (this.mag > decimal.mag) {
            return 1;
        }
        if (this.mag < decimal.mag) {
            return -1;
        }
        return 0;
    }

    public compare(value: DecimalSource): CompareResult {
        return this.cmp(value);
    }

    public isNan(): boolean {
        return isNaN(this.sign) || isNaN(this.layer) || isNaN(this.mag);
    }

    public isFinite(): boolean {
        return isFinite(this.sign) && isFinite(this.layer) && isFinite(this.mag);
    }

    public eq(value: DecimalSource): boolean {
        const decimal = D(value);
        return (
            this.sign === decimal.sign && this.layer === decimal.layer && this.mag === decimal.mag
        );
    }

    public equals(value: DecimalSource): boolean {
        return this.eq(value);
    }

    public neq(value: DecimalSource): boolean {
        return !this.eq(value);
    }

    public notEquals(value: DecimalSource): boolean {
        return this.neq(value);
    }

    public lt(value: DecimalSource): boolean {
        return this.cmp(value) === -1;
    }

    public lte(value: DecimalSource): boolean {
        return !this.gt(value);
    }

    public gt(value: DecimalSource): boolean {
        return this.cmp(value) === 1;
    }

    public gte(value: DecimalSource): boolean {
        return !this.lt(value);
    }

    public max(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.lt(decimal) ? decimal : this;
    }

    public min(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.gt(decimal) ? decimal : this;
    }

    public maxabs(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.cmpabs(decimal) < 0 ? decimal : this;
    }

    public minabs(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.cmpabs(decimal) > 0 ? decimal : this;
    }

    public clamp(min: DecimalSource, max: DecimalSource): Decimal {
        return this.max(min).min(max);
    }

    public clampMin(min: DecimalSource): Decimal {
        return this.max(min);
    }

    public clampMax(max: DecimalSource): Decimal {
        return this.min(max);
    }

    public cmp_tolerance(value: DecimalSource, tolerance: number): CompareResult {
        const decimal = D(value);
        return this.eq_tolerance(decimal, tolerance) ? 0 : this.cmp(decimal);
    }

    public compare_tolerance(value: DecimalSource, tolerance: number): CompareResult {
        return this.cmp_tolerance(value, tolerance);
    }

    /**
     * Tolerance is a relative tolerance, multiplied by the greater of the magnitudes of the two arguments.
     * For example, if you put in 1e-9, then any number closer to the
     * larger number than (larger number)*1e-9 will be considered equal.
     */
    public eq_tolerance(value: DecimalSource, tolerance?: number): boolean {
        const decimal = D(value); // https://stackoverflow.com/a/33024979
        if (tolerance == null) {
            tolerance = 1e-7;
        }
        //Numbers that are too far away are never close.
        if (this.sign !== decimal.sign) {
            return false;
        }
        if (Math.abs(this.layer - decimal.layer) > 1) {
            return false;
        }
        // return abs(a-b) <= tolerance * max(abs(a), abs(b))
        let magA = this.mag;
        let magB = decimal.mag;
        if (this.layer > decimal.layer) {
            magB = f_maglog10(magB);
        }
        if (this.layer < decimal.layer) {
            magA = f_maglog10(magA);
        }
        return Math.abs(magA - magB) <= tolerance * Math.max(Math.abs(magA), Math.abs(magB));
    }

    public equals_tolerance(value: DecimalSource, tolerance: number): boolean {
        return this.eq_tolerance(value, tolerance);
    }

    public neq_tolerance(value: DecimalSource, tolerance: number): boolean {
        return !this.eq_tolerance(value, tolerance);
    }

    public notEquals_tolerance(value: DecimalSource, tolerance: number): boolean {
        return this.neq_tolerance(value, tolerance);
    }

    public lt_tolerance(value: DecimalSource, tolerance: number): boolean {
        const decimal = D(value);
        return !this.eq_tolerance(decimal, tolerance) && this.lt(decimal);
    }

    public lte_tolerance(value: DecimalSource, tolerance: number): boolean {
        const decimal = D(value);
        return this.eq_tolerance(decimal, tolerance) || this.lt(decimal);
    }

    public gt_tolerance(value: DecimalSource, tolerance: number): boolean {
        const decimal = D(value);
        return !this.eq_tolerance(decimal, tolerance) && this.gt(decimal);
    }

    public gte_tolerance(value: DecimalSource, tolerance: number): boolean {
        const decimal = D(value);
        return this.eq_tolerance(decimal, tolerance) || this.gt(decimal);
    }

    public pLog10(): Decimal {
        if (this.lt(Decimal.dZero)) {
            return Decimal.dZero;
        }
        return this.log10();
    }

    public absLog10(): Decimal {
        if (this.sign === 0) {
            return Decimal.dNaN;
        } else if (this.layer > 0) {
            return FC(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
        } else {
            return FC(1, 0, Math.log10(this.mag));
        }
    }

    public log10(): Decimal {
        if (this.sign <= 0) {
            return Decimal.dNaN;
        } else if (this.layer > 0) {
            return FC(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
        } else {
            return FC(this.sign, 0, Math.log10(this.mag));
        }
    }

    public log(base: DecimalSource): Decimal {
        base = D(base);
        if (this.sign <= 0) {
            return Decimal.dNaN;
        }
        if (base.sign <= 0) {
            return Decimal.dNaN;
        }
        if (base.sign === 1 && base.layer === 0 && base.mag === 1) {
            return Decimal.dNaN;
        } else if (this.layer === 0 && base.layer === 0) {
            return FC(this.sign, 0, Math.log(this.mag) / Math.log(base.mag));
        }

        return Decimal.div(this.log10(), base.log10());
    }

    public log2(): Decimal {
        if (this.sign <= 0) {
            return Decimal.dNaN;
        } else if (this.layer === 0) {
            return FC(this.sign, 0, Math.log2(this.mag));
        } else if (this.layer === 1) {
            return FC(Math.sign(this.mag), 0, Math.abs(this.mag) * 3.321928094887362); //log2(10)
        } else if (this.layer === 2) {
            return FC(Math.sign(this.mag), 1, Math.abs(this.mag) + 0.5213902276543247); //-log10(log10(2))
        } else {
            return FC(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
        }
    }

    public ln(): Decimal {
        if (this.sign <= 0) {
            return Decimal.dNaN;
        } else if (this.layer === 0) {
            return FC(this.sign, 0, Math.log(this.mag));
        } else if (this.layer === 1) {
            return FC(Math.sign(this.mag), 0, Math.abs(this.mag) * 2.302585092994046); //ln(10)
        } else if (this.layer === 2) {
            return FC(Math.sign(this.mag), 1, Math.abs(this.mag) + 0.36221568869946325); //log10(log10(e))
        } else {
            return FC(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
        }
    }

    public logarithm(base: DecimalSource): Decimal {
        return this.log(base);
    }

    public pow(value: DecimalSource): Decimal {
        const decimal = D(value);
        const a = this;
        const b = decimal;

        //special case: if a is 0, then return 0 (UNLESS b is 0, then return 1)
        if (a.sign === 0) {
            return b.eq(0) ? FC_NN(1, 0, 1) : a;
        }
        //special case: if a is 1, then return 1
        if (a.sign === 1 && a.layer === 0 && a.mag === 1) {
            return a;
        }
        //special case: if b is 0, then return 1
        if (b.sign === 0) {
            return FC_NN(1, 0, 1);
        }
        //special case: if b is 1, then return a
        if (b.sign === 1 && b.layer === 0 && b.mag === 1) {
            return a;
        }

        const result = a.absLog10().mul(b).pow10();

        if (this.sign === -1) {
            if (Math.abs(b.toNumber() % 2) % 2 === 1) {
                return result.neg();
            } else if (Math.abs(b.toNumber() % 2) % 2 === 0) {
                return result;
            }
            return Decimal.dNaN;
        }

        return result;
    }

    public pow10(): Decimal {
        /*
    There are four cases we need to consider:
    1) positive sign, positive mag (e15, ee15): +1 layer (e.g. 10^15 becomes e15, 10^e15 becomes ee15)
    2) negative sign, positive mag (-e15, -ee15): +1 layer but sign and mag sign are flipped (e.g. 10^-15 becomes e-15, 10^-e15 becomes ee-15)
    3) positive sign, negative mag (e-15, ee-15): layer 0 case would have been handled in the Math.pow check, so just return 1
    4) negative sign, negative mag (-e-15, -ee-15): layer 0 case would have been handled in the Math.pow check, so just return 1
    */

        if (!Number.isFinite(this.layer) || !Number.isFinite(this.mag)) {
            return Decimal.dNaN;
        }

        let a: Decimal = this;

        //handle layer 0 case - if no precision is lost just use Math.pow, else promote one layer
        if (a.layer === 0) {
            const newmag = Math.pow(10, a.sign * a.mag);
            if (Number.isFinite(newmag) && Math.abs(newmag) >= 0.1) {
                return FC(1, 0, newmag);
            } else {
                if (a.sign === 0) {
                    return Decimal.dOne;
                } else {
                    a = FC_NN(a.sign, a.layer + 1, Math.log10(a.mag));
                }
            }
        }

        //handle all 4 layer 1+ cases individually
        if (a.sign > 0 && a.mag >= 0) {
            return FC(a.sign, a.layer + 1, a.mag);
        }
        if (a.sign < 0 && a.mag >= 0) {
            return FC(-a.sign, a.layer + 1, -a.mag);
        }
        //both the negative mag cases are identical: one +/- rounding error
        return Decimal.dOne;
    }

    public pow_base(value: DecimalSource): Decimal {
        return D(value).pow(this);
    }

    public root(value: DecimalSource): Decimal {
        const decimal = D(value);
        return this.pow(decimal.recip());
    }

    public factorial(): Decimal {
        if (this.mag < 0) {
            return this.add(1).gamma();
        } else if (this.layer === 0) {
            return this.add(1).gamma();
        } else if (this.layer === 1) {
            return Decimal.exp(Decimal.mul(this, Decimal.ln(this).sub(1)));
        } else {
            return Decimal.exp(this);
        }
    }

    //from HyperCalc source code
    public gamma(): Decimal {
        if (this.mag < 0) {
            return this.recip();
        } else if (this.layer === 0) {
            if (this.lt(FC_NN(1, 0, 24))) {
                return Decimal.fromNumber(f_gamma(this.sign * this.mag));
            }

            const t = this.mag - 1;
            let l = 0.9189385332046727; //0.5*Math.log(2*Math.PI)
            l = l + (t + 0.5) * Math.log(t);
            l = l - t;
            const n2 = t * t;
            let np = t;
            let lm = 12 * np;
            let adj = 1 / lm;
            let l2 = l + adj;
            if (l2 === l) {
                return Decimal.exp(l);
            }

            l = l2;
            np = np * n2;
            lm = 360 * np;
            adj = 1 / lm;
            l2 = l - adj;
            if (l2 === l) {
                return Decimal.exp(l);
            }

            l = l2;
            np = np * n2;
            lm = 1260 * np;
            let lt = 1 / lm;
            l = l + lt;
            np = np * n2;
            lm = 1680 * np;
            lt = 1 / lm;
            l = l - lt;
            return Decimal.exp(l);
        } else if (this.layer === 1) {
            return Decimal.exp(Decimal.mul(this, Decimal.ln(this).sub(1)));
        } else {
            return Decimal.exp(this);
        }
    }

    public lngamma(): Decimal {
        return this.gamma().ln();
    }

    public exp(): Decimal {
        if (this.mag < 0) {
            return Decimal.dOne;
        }
        if (this.layer === 0 && this.mag <= 709.7) {
            return Decimal.fromNumber(Math.exp(this.sign * this.mag));
        } else if (this.layer === 0) {
            return FC(1, 1, this.sign * Math.log10(Math.E) * this.mag);
        } else if (this.layer === 1) {
            return FC(1, 2, this.sign * (Math.log10(0.4342944819032518) + this.mag));
        } else {
            return FC(1, this.layer + 1, this.sign * this.mag);
        }
    }

    public sqr(): Decimal {
        return this.pow(2);
    }

    public sqrt(): Decimal {
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.sqrt(this.sign * this.mag));
        } else if (this.layer === 1) {
            return FC(1, 2, Math.log10(this.mag) - 0.3010299956639812);
        } else {
            const result = Decimal.div(FC_NN(this.sign, this.layer - 1, this.mag), FC_NN(1, 0, 2));
            result.layer += 1;
            result.normalize();
            return result;
        }
    }

    public cube(): Decimal {
        return this.pow(3);
    }

    public cbrt(): Decimal {
        return this.pow(1 / 3);
    }

    //Tetration/tetrate: The result of exponentiating 'this' to 'this' 'height' times in a row.  https://en.wikipedia.org/wiki/Tetration
    //If payload != 1, then this is 'iterated exponentiation', the result of exping (payload) to base (this) (height) times. https://andydude.github.io/tetration/archives/tetration2/ident.html
    //Works with negative and positive real heights.
    public tetrate(height = 2, payload: DecimalSource = FC_NN(1, 0, 1)): Decimal {
        //x^^1 == x
        if (height === 1) {
            return Decimal.pow(this, payload);
        }
        //x^^0 == 1
        if (height === 0) {
            return new Decimal(payload);
        }
        //1^^x == 1
        if (this.eq(Decimal.dOne)) {
            return Decimal.dOne;
        }
        //-1^^x == -1
        if (this.eq(-1)) {
            return Decimal.pow(this, payload);
        }

        if (height === Number.POSITIVE_INFINITY) {
            const this_num = this.toNumber();
            //within the convergence range?
            if (this_num <= 1.44466786100976613366 && this_num >= 0.06598803584531253708) {
                //hotfix for the very edge of the number range not being handled properly
                if (this_num > 1.444667861009099) {
                    return Decimal.fromNumber(Math.E);
                }
                //Formula for infinite height power tower.
                const negln = Decimal.ln(this).neg();
                return negln.lambertw().div(negln);
            } else if (this_num > 1.44466786100976613366) {
                //explodes to infinity
                // TODO: replace this with Decimal.dInf
                return Decimal.fromNumber(Number.POSITIVE_INFINITY);
            } else {
                //0.06598803584531253708 > this_num >= 0: never converges
                //this_num < 0: quickly becomes a complex number
                return Decimal.dNaN;
            }
        }

        //0^^x oscillates if we define 0^0 == 1 (which in javascript land we do), since then 0^^1 is 0, 0^^2 is 1, 0^^3 is 0, etc. payload is ignored
        //using the linear approximation for height (TODO: don't know a better way to calculate it ATM, but it wouldn't surprise me if it's just NaN)
        if (this.eq(Decimal.dZero)) {
            let result = Math.abs((height + 1) % 2);
            if (result > 1) {
                result = 2 - result;
            }
            return Decimal.fromNumber(result);
        }

        if (height < 0) {
            return Decimal.iteratedlog(payload, this, -height);
        }

        payload = D(payload);
        const oldheight = height;
        height = Math.trunc(height);
        const fracheight = oldheight - height;

        if (this.gt(Decimal.dZero) && this.lte(1.44466786100976613366)) {
            //similar to 0^^n, flip-flops between two values, converging slowly (or if it's below 0.06598803584531253708, never. so once again, the fractional part at the end will be a linear approximation (TODO: again pending knowledge of how to approximate better, although tbh I think it should in reality just be NaN)
            height = Math.min(10000, height);
            for (let i = 0; i < height; ++i) {
                const old_payload: Decimal = payload;
                payload = this.pow(payload);
                //stop early if we converge
                if (old_payload.eq(payload)) {
                    return payload;
                }
            }
            if (fracheight != 0) {
                const next_payload = this.pow(payload);
                return payload.mul(1 - fracheight).add(next_payload.mul(fracheight));
            }
            return payload;
        }
        //TODO: base < 0, but it's hard for me to reason about (probably all non-integer heights are NaN automatically?)

        if (fracheight !== 0) {
            if (payload.eq(Decimal.dOne)) {
                //TODO: for bases above 10, revert to old linear approximation until I can think of something better
                if (this.gt(10)) {
                    payload = this.pow(fracheight);
                } else {
                    payload = Decimal.fromNumber(
                        Decimal.tetrate_critical(this.toNumber(), fracheight)
                    );
                    //TODO: until the critical section grid can handle numbers below 2, scale them to the base
                    //TODO: maybe once the critical section grid has very large bases, this math can be appropriate for them too? I'll think about it
                    if (this.lt(2)) {
                        payload = payload.sub(1).mul(this.minus(1)).plus(1);
                    }
                }
            } else {
                if (this.eq(10)) {
                    payload = payload.layeradd10(fracheight);
                } else {
                    payload = payload.layeradd(fracheight, this);
                }
            }
        }

        for (let i = 0; i < height; ++i) {
            payload = this.pow(payload);
            //bail if we're NaN
            if (!isFinite(payload.layer) || !isFinite(payload.mag)) {
                return payload.normalize();
            }
            //shortcut
            if (payload.layer - this.layer > 3) {
                return FC_NN(payload.sign, payload.layer + (height - i - 1), payload.mag);
            }
            //give up after 10000 iterations if nothing is happening
            if (i > 10000) {
                return payload;
            }
        }
        return payload;
    }

    //iteratedexp/iterated exponentiation: - all cases handled in tetrate, so just call it
    public iteratedexp(height = 2, payload = FC_NN(1, 0, 1)): Decimal {
        return this.tetrate(height, payload);
    }

    //iterated log/repeated log: The result of applying log(base) 'times' times in a row. Approximately equal to subtracting (times) from the number's slog representation. Equivalent to tetrating to a negative height.
    //Works with negative and positive real heights.
    public iteratedlog(base: DecimalSource = 10, times = 1): Decimal {
        if (times < 0) {
            return Decimal.tetrate(base, -times, this);
        }

        base = D(base);
        let result = Decimal.fromDecimal(this);
        const fulltimes = times;
        times = Math.trunc(times);
        const fraction = fulltimes - times;
        if (result.layer - base.layer > 3) {
            const layerloss = Math.min(times, result.layer - base.layer - 3);
            times -= layerloss;
            result.layer -= layerloss;
        }

        for (let i = 0; i < times; ++i) {
            result = result.log(base);
            //bail if we're NaN
            if (!isFinite(result.layer) || !isFinite(result.mag)) {
                return result.normalize();
            }
            //give up after 10000 iterations if nothing is happening
            if (i > 10000) {
                return result;
            }
        }

        //handle fractional part
        if (fraction > 0 && fraction < 1) {
            if (base.eq(10)) {
                result = result.layeradd10(-fraction);
            } else {
                result = result.layeradd(-fraction, base);
            }
        }

        return result;
    }

    //Super-logarithm, one of tetration's inverses, tells you what size power tower you'd have to tetrate base to to get number. By definition, will never be higher than 1.8e308 in break_eternity.js, since a power tower 1.8e308 numbers tall is the largest representable number.
    // https://en.wikipedia.org/wiki/Super-logarithm
    // NEW: Accept a number of iterations, and use binary search to, after making an initial guess, hone in on the true value, assuming tetration as the ground truth.
    public slog(base: DecimalSource = 10, iterations = 100): Decimal {
        let step_size = 0.001;
        let has_changed_directions_once = false;
        let previously_rose = false;
        let result = this.slog_internal(base).toNumber();
        for (let i = 1; i < iterations; ++i) {
            const new_decimal = new Decimal(base).tetrate(result);
            const currently_rose = new_decimal.gt(this);
            if (i > 1) {
                if (previously_rose != currently_rose) {
                    has_changed_directions_once = true;
                }
            }
            previously_rose = currently_rose;
            if (has_changed_directions_once) {
                step_size /= 2;
            } else {
                step_size *= 2;
            }
            step_size = Math.abs(step_size) * (currently_rose ? -1 : 1);
            result += step_size;
            if (step_size === 0) {
                break;
            }
        }
        return Decimal.fromNumber(result);
    }

    public slog_internal(base: DecimalSource = 10): Decimal {
        base = D(base);

        //special cases:
        //slog base 0 or lower is NaN
        if (base.lte(Decimal.dZero)) {
            return Decimal.dNaN;
        }
        //slog base 1 is NaN
        if (base.eq(Decimal.dOne)) {
            return Decimal.dNaN;
        }
        //need to handle these small, wobbling bases specially
        if (base.lt(Decimal.dOne)) {
            if (this.eq(Decimal.dOne)) {
                return Decimal.dZero;
            }
            if (this.eq(Decimal.dZero)) {
                return Decimal.dNegOne;
            }
            //0 < this < 1: ambiguous (happens multiple times)
            //this < 0: impossible (as far as I can tell)
            //this > 1: partially complex (http://myweb.astate.edu/wpaulsen/tetcalc/tetcalc.html base 0.25 for proof)
            return Decimal.dNaN;
        }
        //slog_n(0) is -1
        if (this.mag < 0 || this.eq(Decimal.dZero)) {
            return Decimal.dNegOne;
        }

        let result = 0;
        let copy = Decimal.fromDecimal(this);
        if (copy.layer - base.layer > 3) {
            const layerloss = copy.layer - base.layer - 3;
            result += layerloss;
            copy.layer -= layerloss;
        }

        for (let i = 0; i < 100; ++i) {
            if (copy.lt(Decimal.dZero)) {
                copy = Decimal.pow(base, copy);
                result -= 1;
            } else if (copy.lte(Decimal.dOne)) {
                return Decimal.fromNumber(
                    result + Decimal.slog_critical(base.toNumber(), copy.toNumber())
                );
            } else {
                result += 1;
                copy = Decimal.log(copy, base);
            }
        }
        return Decimal.fromNumber(result);
    }

    //background info and tables of values for critical functions taken here: https://github.com/Patashu/break_eternity.js/issues/22
    public static slog_critical(base: number, height: number): number {
        //TODO: for bases above 10, revert to old linear approximation until I can think of something better
        if (base > 10) {
            return height - 1;
        }
        return Decimal.critical_section(base, height, critical_slog_values);
    }

    public static tetrate_critical(base: number, height: number): number {
        return Decimal.critical_section(base, height, critical_tetr_values);
    }

    public static critical_section(base: number, height: number, grid: number[][]): number {
        //this part is simple at least, since it's just 0.1 to 0.9
        height *= 10;
        if (height < 0) {
            height = 0;
        }
        if (height > 10) {
            height = 10;
        }
        //have to do this complicated song and dance since one of the critical_headers is Math.E, and in the future I'd like 1.5 as well
        if (base < 2) {
            base = 2;
        }
        if (base > 10) {
            base = 10;
        }
        let lower = 0;
        let upper = 0;
        //basically, if we're between bases, we interpolate each bases' relevant values together
        //then we interpolate based on what the fractional height is.
        //accuracy could be improved by doing a non-linear interpolation (maybe), by adding more bases and heights (definitely) but this is AFAIK the best you can get without running some pari.gp or mathematica program to calculate exact values
        //however, do note http://myweb.astate.edu/wpaulsen/tetcalc/tetcalc.html can do it for arbitrary heights but not for arbitrary bases (2, e, 10 present)
        for (let i = 0; i < critical_headers.length; ++i) {
            if (critical_headers[i] == base) {
                // exact match
                lower = grid[i][Math.floor(height)];
                upper = grid[i][Math.ceil(height)];
                break;
            } else if (critical_headers[i] < base && critical_headers[i + 1] > base) {
                // interpolate between this and the next
                const basefrac =
                    (base - critical_headers[i]) / (critical_headers[i + 1] - critical_headers[i]);
                lower =
                    grid[i][Math.floor(height)] * (1 - basefrac) +
                    grid[i + 1][Math.floor(height)] * basefrac;
                upper =
                    grid[i][Math.ceil(height)] * (1 - basefrac) +
                    grid[i + 1][Math.ceil(height)] * basefrac;
                break;
            }
        }
        const frac = height - Math.floor(height);
        //improvement - you get more accuracy (especially around 0.9-1.0) by doing log, then frac, then powing the result
        //(we could pre-log the lookup table, but then fractional bases would get Weird)
        //also, use old linear for slog (values 0 or less in critical section). maybe something else is better but haven't thought about what yet
        if (lower <= 0 || upper <= 0) {
            return lower * (1 - frac) + upper * frac;
        } else {
            return Math.pow(
                base,
                (Math.log(lower) / Math.log(base)) * (1 - frac) +
                    (Math.log(upper) / Math.log(base)) * frac
            );
        }
    }

    //Function for adding/removing layers from a Decimal, even fractional layers (e.g. its slog10 representation).
    //Moved this over to use the same critical section as tetrate/slog.
    public layeradd10(diff: DecimalSource): Decimal {
        diff = Decimal.fromValue_noAlloc(diff).toNumber();
        const result = Decimal.fromDecimal(this);
        if (diff >= 1) {
            //bug fix: if result is very smol (mag < 0, layer > 0) turn it into 0 first
            if (result.mag < 0 && result.layer > 0) {
                result.sign = 0;
                result.mag = 0;
                result.layer = 0;
            } else if (result.sign === -1 && result.layer == 0) {
                //bug fix - for stuff like -3.layeradd10(1) we need to move the sign to the mag
                result.sign = 1;
                result.mag = -result.mag;
            }
            const layeradd = Math.trunc(diff);
            diff -= layeradd;
            result.layer += layeradd;
        }
        if (diff <= -1) {
            const layeradd = Math.trunc(diff);
            diff -= layeradd;
            result.layer += layeradd;
            if (result.layer < 0) {
                for (let i = 0; i < 100; ++i) {
                    result.layer++;
                    result.mag = Math.log10(result.mag);
                    if (!isFinite(result.mag)) {
                        //another bugfix: if we hit -Infinity mag, then we should return negative infinity, not 0. 0.layeradd10(-1) h its this
                        if (result.sign === 0) {
                            result.sign = 1;
                        }
                        //also this, for 0.layeradd10(-2)
                        if (result.layer < 0) {
                            result.layer = 0;
                        }
                        return result.normalize();
                    }
                    if (result.layer >= 0) {
                        break;
                    }
                }
            }
        }

        while (result.layer < 0) {
            result.layer++;
            result.mag = Math.log10(result.mag);
        }
        //bugfix: before we normalize: if we started with 0, we now need to manually fix a layer ourselves!
        if (result.sign === 0) {
            result.sign = 1;
            if (result.mag === 0 && result.layer >= 1) {
                result.layer -= 1;
                result.mag = 1;
            }
        }
        result.normalize();

        //layeradd10: like adding 'diff' to the number's slog(base) representation. Very similar to tetrate base 10 and iterated log base 10. Also equivalent to adding a fractional amount to the number's layer in its break_eternity.js representation.
        if (diff !== 0) {
            return result.layeradd(diff, 10); //safe, only calls positive height 1 payload tetration, slog and log
        }

        return result;
    }

    //layeradd: like adding 'diff' to the number's slog(base) representation. Very similar to tetrate base 'base' and iterated log base 'base'.
    public layeradd(diff: number, base: DecimalSource): Decimal {
        const slogthis = this.slog(base).toNumber();
        const slogdest = slogthis + diff;
        if (slogdest >= 0) {
            return Decimal.tetrate(base, slogdest);
        } else if (!Number.isFinite(slogdest)) {
            return Decimal.dNaN;
        } else if (slogdest >= -1) {
            return Decimal.log(Decimal.tetrate(base, slogdest + 1), base);
        } else {
            return Decimal.log(Decimal.log(Decimal.tetrate(base, slogdest + 2), base), base);
        }
    }

    //The Lambert W function, also called the omega function or product logarithm, is the solution W(x) === x*e^x.
    // https://en.wikipedia.org/wiki/Lambert_W_function
    //Some special values, for testing: https://en.wikipedia.org/wiki/Lambert_W_function#Special_values
    public lambertw(): Decimal {
        if (this.lt(-0.3678794411710499)) {
            throw Error("lambertw is unimplemented for results less than -1, sorry!");
        } else if (this.mag < 0) {
            return Decimal.fromNumber(f_lambertw(this.toNumber()));
        } else if (this.layer === 0) {
            return Decimal.fromNumber(f_lambertw(this.sign * this.mag));
        } else if (this.layer === 1) {
            return d_lambertw(this);
        } else if (this.layer === 2) {
            return d_lambertw(this);
        }
        if (this.layer >= 3) {
            return FC_NN(this.sign, this.layer - 1, this.mag);
        }

        throw "Unhandled behavior in lambertw()";
    }

    //The super square-root function - what number, tetrated to height 2, equals this?
    //Other sroots are possible to calculate probably through guess and check methods, this one is easy though.
    // https://en.wikipedia.org/wiki/Tetration#Super-root
    public ssqrt(): Decimal {
        if (this.sign == 1 && this.layer >= 3) {
            return FC_NN(this.sign, this.layer - 1, this.mag);
        }
        const lnx = this.ln();
        return lnx.div(lnx.lambertw());
    }

    //Pentation/pentate: The result of tetrating 'height' times in a row. An absurdly strong operator - Decimal.pentate(2, 4.28) and Decimal.pentate(10, 2.37) are already too huge for break_eternity.js!
    // https://en.wikipedia.org/wiki/Pentation
    public pentate(height = 2, payload: DecimalSource = FC_NN(1, 0, 1)): Decimal {
        payload = D(payload);
        const oldheight = height;
        height = Math.trunc(height);
        const fracheight = oldheight - height;

        //I have no idea if this is a meaningful approximation for pentation to continuous heights, but it is monotonic and continuous.
        if (fracheight !== 0) {
            if (payload.eq(Decimal.dOne)) {
                ++height;
                payload = Decimal.fromNumber(fracheight);
            } else {
                if (this.eq(10)) {
                    payload = payload.layeradd10(fracheight);
                } else {
                    payload = payload.layeradd(fracheight, this);
                }
            }
        }

        for (let i = 0; i < height; ++i) {
            payload = this.tetrate(payload.toNumber());
            //bail if we're NaN
            if (!isFinite(payload.layer) || !isFinite(payload.mag)) {
                return payload.normalize();
            }
            //give up after 10 iterations if nothing is happening
            if (i > 10) {
                return payload;
            }
        }

        return payload;
    }

    // trig functions!
    public sin(): this | Decimal {
        if (this.mag < 0) {
            return this;
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.sin(this.sign * this.mag));
        }
        return FC_NN(0, 0, 0);
    }

    public cos(): Decimal {
        if (this.mag < 0) {
            return Decimal.dOne;
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.cos(this.sign * this.mag));
        }
        return FC_NN(0, 0, 0);
    }

    public tan(): this | Decimal {
        if (this.mag < 0) {
            return this;
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.tan(this.sign * this.mag));
        }
        return FC_NN(0, 0, 0);
    }

    public asin(): this | Decimal {
        if (this.mag < 0) {
            return this;
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.asin(this.sign * this.mag));
        }
        return FC_NN(Number.NaN, Number.NaN, Number.NaN);
    }

    public acos(): Decimal {
        if (this.mag < 0) {
            return Decimal.fromNumber(Math.acos(this.toNumber()));
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.acos(this.sign * this.mag));
        }
        return FC_NN(Number.NaN, Number.NaN, Number.NaN);
    }

    public atan(): this | Decimal {
        if (this.mag < 0) {
            return this;
        }
        if (this.layer === 0) {
            return Decimal.fromNumber(Math.atan(this.sign * this.mag));
        }
        return Decimal.fromNumber(Math.atan(this.sign * 1.8e308));
    }

    public sinh(): Decimal {
        return this.exp().sub(this.negate().exp()).div(2);
    }

    public cosh(): Decimal {
        return this.exp().add(this.negate().exp()).div(2);
    }

    public tanh(): Decimal {
        return this.sinh().div(this.cosh());
    }

    public asinh(): Decimal {
        return Decimal.ln(this.add(this.sqr().add(1).sqrt()));
    }

    public acosh(): Decimal {
        return Decimal.ln(this.add(this.sqr().sub(1).sqrt()));
    }

    public atanh(): Decimal {
        if (this.abs().gte(1)) {
            return FC_NN(Number.NaN, Number.NaN, Number.NaN);
        }

        return Decimal.ln(this.add(1).div(Decimal.fromNumber(1).sub(this))).div(2);
    }

    /**
     * Joke function from Realm Grinder
     */
    public ascensionPenalty(ascensions: DecimalSource): Decimal {
        if (ascensions === 0) {
            return this;
        }

        return this.root(Decimal.pow(10, ascensions));
    }

    /**
     * Joke function from Cookie Clicker. It's 'egg'
     */
    public egg(): Decimal {
        return this.add(9);
    }

    public lessThanOrEqualTo(other: DecimalSource): boolean {
        return this.cmp(other) < 1;
    }

    public lessThan(other: DecimalSource): boolean {
        return this.cmp(other) < 0;
    }

    public greaterThanOrEqualTo(other: DecimalSource): boolean {
        return this.cmp(other) > -1;
    }

    public greaterThan(other: DecimalSource): boolean {
        return this.cmp(other) > 0;
    }

    // return Decimal;
}

// Assign these after the Decimal is assigned because vitest had issues otherwise
// If we can figure out why, we can make these readonly properties instead
Decimal.dZero = FC_NN(0, 0, 0);
Decimal.dOne = FC_NN(1, 0, 1);
Decimal.dNegOne = FC_NN(-1, 0, 1);
Decimal.dTwo = FC_NN(1, 0, 2);
Decimal.dTen = FC_NN(1, 0, 10);
Decimal.dNaN = FC_NN(Number.NaN, Number.NaN, Number.NaN);
Decimal.dInf = FC_NN(1, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
Decimal.dNegInf = FC_NN(-1, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY);
Decimal.dNumberMax = FC(1, 0, Number.MAX_VALUE);
Decimal.dNumberMin = FC(1, 0, Number.MIN_VALUE);

// return Decimal;

// Optimise Decimal aliases.
// We can't do this optimisation before Decimal is assigned.
D = Decimal.fromValue_noAlloc;
FC = Decimal.fromComponents;
FC_NN = Decimal.fromComponents_noNormalize;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
ME = Decimal.fromMantissaExponent;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
ME_NN = Decimal.fromMantissaExponent_noNormalize;