nerdamer 1.1.13 → 2.0.0-rc.1

package/output/math/trig.js

@@ -0,0 +1,1444 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INVERSE_HYPERBOLIC_TRIG = exports.HYPERBOLIC_TRIG = exports.INVERSE_TRIG = exports.TRIG = exports.ACOTH = exports.ACSCH = exports.ASECH = exports.ATANH = exports.ASINH = exports.ACOSH = exports.COTH = exports.CSCH = exports.SECH = exports.TANH = exports.COSH = exports.SINH = exports.ATAN2 = exports.ACOT = exports.ACSC = exports.ASEC = exports.ATAN = exports.COT = exports.CSC = exports.SEC = exports.ACOS = exports.ASIN = exports.TAN = exports.SIN = exports.COS = exports.TRIG_FUNCTION_NAMES = void 0;
+exports.cos = cos;
+exports.sin = sin;
+exports.tan = tan;
+exports.sec = sec;
+exports.csc = csc;
+exports.cot = cot;
+exports.acos = acos;
+exports.asin = asin;
+exports.atan = atan;
+exports.asec = asec;
+exports.acsc = acsc;
+exports.acot = acot;
+exports.atan2 = atan2;
+exports.cosh = cosh;
+exports.sinh = sinh;
+exports.tanh = tanh;
+exports.sech = sech;
+exports.csch = csch;
+exports.coth = coth;
+exports.acosh = acosh;
+exports.asinh = asinh;
+exports.atanh = atanh;
+exports.asech = asech;
+exports.acsch = acsch;
+exports.acoth = acoth;
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const constants_1 = require("../core/classes/parser/constants");
+const Rational_1 = require("../core/classes/rational/Rational");
+const errors_1 = require("../core/errors");
+const bigint_1 = require("../core/functions/bigint/bigint");
+const Settings_1 = require("../core/Settings");
+const geometry_1 = require("./geometry");
+const math_1 = require("./math");
+const math_2 = require("./math");
+var constants_2 = require("../core/classes/parser/constants");
+Object.defineProperty(exports, "TRIG_FUNCTION_NAMES", { enumerable: true, get: function () { return constants_2.TRIG_FUNCTION_NAMES; } });
+Object.defineProperty(exports, "COS", { enumerable: true, get: function () { return constants_2.COS; } });
+Object.defineProperty(exports, "SIN", { enumerable: true, get: function () { return constants_2.SIN; } });
+Object.defineProperty(exports, "TAN", { enumerable: true, get: function () { return constants_2.TAN; } });
+Object.defineProperty(exports, "ASIN", { enumerable: true, get: function () { return constants_2.ASIN; } });
+Object.defineProperty(exports, "ACOS", { enumerable: true, get: function () { return constants_2.ACOS; } });
+Object.defineProperty(exports, "SEC", { enumerable: true, get: function () { return constants_2.SEC; } });
+Object.defineProperty(exports, "CSC", { enumerable: true, get: function () { return constants_2.CSC; } });
+Object.defineProperty(exports, "COT", { enumerable: true, get: function () { return constants_2.COT; } });
+Object.defineProperty(exports, "ATAN", { enumerable: true, get: function () { return constants_2.ATAN; } });
+Object.defineProperty(exports, "ASEC", { enumerable: true, get: function () { return constants_2.ASEC; } });
+Object.defineProperty(exports, "ACSC", { enumerable: true, get: function () { return constants_2.ACSC; } });
+Object.defineProperty(exports, "ACOT", { enumerable: true, get: function () { return constants_2.ACOT; } });
+Object.defineProperty(exports, "ATAN2", { enumerable: true, get: function () { return constants_2.ATAN2; } });
+Object.defineProperty(exports, "SINH", { enumerable: true, get: function () { return constants_2.SINH; } });
+Object.defineProperty(exports, "COSH", { enumerable: true, get: function () { return constants_2.COSH; } });
+Object.defineProperty(exports, "TANH", { enumerable: true, get: function () { return constants_2.TANH; } });
+Object.defineProperty(exports, "SECH", { enumerable: true, get: function () { return constants_2.SECH; } });
+Object.defineProperty(exports, "CSCH", { enumerable: true, get: function () { return constants_2.CSCH; } });
+Object.defineProperty(exports, "COTH", { enumerable: true, get: function () { return constants_2.COTH; } });
+Object.defineProperty(exports, "ACOSH", { enumerable: true, get: function () { return constants_2.ACOSH; } });
+Object.defineProperty(exports, "ASINH", { enumerable: true, get: function () { return constants_2.ASINH; } });
+Object.defineProperty(exports, "ATANH", { enumerable: true, get: function () { return constants_2.ATANH; } });
+Object.defineProperty(exports, "ASECH", { enumerable: true, get: function () { return constants_2.ASECH; } });
+Object.defineProperty(exports, "ACSCH", { enumerable: true, get: function () { return constants_2.ACSCH; } });
+Object.defineProperty(exports, "ACOTH", { enumerable: true, get: function () { return constants_2.ACOTH; } });
+Object.defineProperty(exports, "TRIG", { enumerable: true, get: function () { return constants_2.TRIG; } });
+Object.defineProperty(exports, "INVERSE_TRIG", { enumerable: true, get: function () { return constants_2.INVERSE_TRIG; } });
+Object.defineProperty(exports, "HYPERBOLIC_TRIG", { enumerable: true, get: function () { return constants_2.HYPERBOLIC_TRIG; } });
+Object.defineProperty(exports, "INVERSE_HYPERBOLIC_TRIG", { enumerable: true, get: function () { return constants_2.INVERSE_HYPERBOLIC_TRIG; } });
+/**
+ * Gets the quadrant of the trig function
+ * @param x
+ * @returns
+ */
+function getQuadrant(x) {
+    const pi = Rational_1.Rational.PI.toDecimal();
+    const twoPi = pi.times(2);
+    // Get the angle by removing multiples of pi
+    let theta = x.toDecimal().mod(twoPi);
+    // Make it a positive angle
+    if (theta.lt(0)) {
+        theta = theta.plus(twoPi);
+    }
+    const quadrant = Math.floor(Number(theta.div(pi.div(2)))) + 1;
+    // Ensure no more than 4
+    return Math.min(quadrant, 4);
+}
+/**
+ * Checks to see if a Expression is a multiple of pi. If so it returns the evaluated
+ * version. Otherwise, the Expression is untouched.
+ *
+ * @param x
+ * @returns
+ */
+function toPiValue(x) {
+    let retval = x;
+    if (constants_1.PI.includes(x.value) && x.isLinear()) {
+        retval = x.evaluate({ [x.value]: `${Rational_1.Rational.PI}` });
+    }
+    return retval;
+}
+// function argNumDen(x: Expression, withR:true): [Expression, Expression, Expression];
+// function argNumDen(x: Expression, withR:false): [Expression, Expression];
+function argNumDen(x, withR = false) {
+    const arg = x.getArguments()[0];
+    const num = arg.getNumerator();
+    const den = arg.getDenominator();
+    const retval = [num, den];
+    if (withR) {
+        retval.push((0, geometry_1.hypot)(num, den));
+    }
+    return retval;
+}
+/**
+ * Computes the cosine of an expression. Returns exact symbolic values for
+ * well-known multiples of π (π/6, π/4, π/3, π/2, π, etc.).
+ *
+ * Cosine is an even function: `cos(-x)` automatically simplifies to `cos(x)`.
+ * Inverse trig compositions are resolved:
+ * - `cos(acos(x))` returns `x`
+ * - `cos(asin(x))` returns `sqrt(1 − x²)`
+ * - `cos(atan(x))` returns `1/sqrt(1 + x²)`
+ *
+ * @param x - The angle in radians.
+ * @returns The cosine of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * cos(0).text()             // "1"
+ * cos('pi').text()          // "-1"
+ * cos('pi/2').text()        // "0"
+ * cos('pi/3').text()        // "1/2"
+ * cos('pi/4').text()        // "1/2*sqrt(2)"
+ * cos('pi/6').text()        // "1/2*sqrt(3)"
+ *
+ * // Symbolic
+ * cos('x').text()           // "cos(x)"
+ * ```
+ */
+function cos(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // cos(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    // cos is an even function: cos(-x) = cos(x)
+    if (x.sign() === -1 && !x.isNUM()) {
+        return cos(x.neg());
+    }
+    const m = Math.abs(+x.getMultiplier());
+    if (m === 1 && x.isFunction(constants_1.ATAN)) {
+        const [, den, r] = argNumDen(x, true);
+        retval = den.div(r);
+    }
+    else if (m === 1 && x.isFunction(constants_1.ACOS)) {
+        retval = x.getArguments()[0];
+    }
+    else if (m === 1 && x.isFunction(constants_1.ASIN)) {
+        const [num, den] = argNumDen(x);
+        retval = (0, math_1.sqrt)(den.sq().minus(num.sq())).div(den);
+    }
+    else {
+        // Create a temporary variable. We can use this to substitute for pi and simplification
+        const t = toPiValue(x);
+        // A flag to check the quadrant. This should be done if a pi substitution was performed.
+        let checkQuadrant = true;
+        // The quadrants in which cosine is negative
+        const quadrants = [2, 3];
+        if (t.isNUM()) {
+            const a = t.getMultiplier();
+            // Check its ratio to pi
+            const r = a.div(Rational_1.Rational.PI);
+            // cos is one for all even pi and -1 for odd
+            if (r.isInteger()) {
+                // Return 1 or -1 for multiples of pi
+                retval = Expression_1.Expression.Number((0, bigint_1.isEven)(r.numerator) ? '1' : '-1');
+            }
+            else {
+                // Modify based on the denominator
+                switch (r.denominator) {
+                    // n*pi/2
+                    case 2n:
+                        retval = (0, shortcuts_1.zero)();
+                        break;
+                    case 3n:
+                        retval = (0, shortcuts_1.one)().div((0, shortcuts_1.two)());
+                        break;
+                    case 4n:
+                        // Return 1/sqrt(2)
+                        retval = (0, shortcuts_1.one)().div((0, math_1.sqrt)((0, shortcuts_1.two)()));
+                        break;
+                    case 6n:
+                        // Return sqrt(3)/2
+                        retval = (0, math_1.sqrt)((0, shortcuts_1.three)()).div((0, shortcuts_1.two)());
+                        break;
+                    default:
+                        // Don't check the quadrant since no pi substitution was performed
+                        checkQuadrant = false;
+                        // If evaluate is called then return the value
+                        if (Settings_1.Settings.EVALUATE) {
+                            retval = Expression_1.Expression.Number(a.toDecimal().cos());
+                        }
+                        else {
+                            // Otherwise return a symbolic function
+                            retval = Expression_1.Expression.toFunction(constants_1.COS, [x]);
+                        }
+                        break;
+                }
+                if (checkQuadrant && r.denominator !== 2n && quadrants.includes(getQuadrant(a))) {
+                    retval = retval.neg();
+                }
+            }
+        }
+        else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+            const re = x.realPart();
+            const im = x.imagPart();
+            retval = cos(re)
+                .times(cosh(im))
+                .minus(sin(re).times(sinh(im)).i());
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.COS, [x]);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the sine of an expression. Returns exact symbolic values for
+ * well-known multiples of π (π/6, π/4, π/3, π/2, π, etc.).
+ *
+ * Sine is an odd function: `sin(-x)` automatically simplifies to `-sin(x)`.
+ * Inverse trig compositions are resolved:
+ * - `sin(asin(x))` returns `x`
+ * - `sin(acos(x))` returns `sqrt(1 − x²)`
+ * - `sin(atan(x))` returns `x/sqrt(1 + x²)`
+ *
+ * @param x - The angle in radians.
+ * @returns The sine of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * sin(0).text()             // "0"
+ * sin('pi').text()          // "0"
+ * sin('pi/2').text()        // "1"
+ * sin('pi/6').text()        // "1/2"
+ * sin('pi/4').text()        // "1/2*sqrt(2)"
+ * sin('pi/3').text()        // "1/2*sqrt(3)"
+ *
+ * // Symbolic
+ * sin('x').text()           // "sin(x)"
+ * ```
+ */
+function sin(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // sin(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    // sin is an odd function: sin(-x) = -sin(x)
+    if (x.sign() === -1 && !x.isNUM()) {
+        return sin(x.neg()).neg();
+    }
+    const m = Math.abs(+x.getMultiplier());
+    if (m === 1 && x.isFunction(constants_1.ATAN)) {
+        const [num, , r] = argNumDen(x, true);
+        retval = num.div(r).times(x.sign());
+    }
+    else if (m === 1 && x.isFunction(constants_1.ASIN)) {
+        retval = x.getArguments()[0].times(x.sign());
+    }
+    else if (m === 1 && x.isFunction(constants_1.ACOS)) {
+        const [num, den] = argNumDen(x);
+        retval = (0, math_1.sqrt)(den.sq().minus(num.sq())).div(den).times(x.sign());
+    }
+    else {
+        // Create a temporary variable. We can use this to substitute for pi and simplification
+        const t = toPiValue(x);
+        // A flag to check the quadrant. This should be done if a pi substitution was performed.
+        let checkQuadrant = true;
+        // The quadrants in which the sine function is negative
+        const quadrants = [3, 4];
+        if (t.isNUM()) {
+            const a = t.getMultiplier();
+            // Check its ratio to pi
+            const r = a.div(Rational_1.Rational.PI);
+            if (r.isInteger()) {
+                // sin is zero for all multiples of pi
+                retval = (0, shortcuts_1.zero)();
+            }
+            else {
+                // Modify based on the denominator
+                switch (r.denominator) {
+                    // n*pi/2
+                    case 2n:
+                        retval = (0, shortcuts_1.one)();
+                        break;
+                    case 3n:
+                        // Return sqrt(3)/2
+                        retval = (0, math_1.sqrt)((0, shortcuts_1.three)()).div((0, shortcuts_1.two)());
+                        break;
+                    case 4n:
+                        // Return 1/sqrt(2)
+                        retval = (0, shortcuts_1.one)().div((0, math_1.sqrt)((0, shortcuts_1.two)()));
+                        break;
+                    case 6n:
+                        // Return 1/2
+                        retval = (0, shortcuts_1.one)().div((0, shortcuts_1.two)());
+                        break;
+                    default:
+                        // Don't check the quadrant since no pi substitution was performed
+                        checkQuadrant = false;
+                        // If evaluate is called then return the value
+                        if (Settings_1.Settings.EVALUATE) {
+                            retval = Expression_1.Expression.Number(a.toDecimal().sin());
+                        }
+                        else {
+                            // Otherwise return a symbolic function
+                            retval = Expression_1.Expression.toFunction(constants_1.SIN, [x]);
+                        }
+                        break;
+                }
+                if (checkQuadrant && quadrants.includes(getQuadrant(a))) {
+                    retval = retval.neg();
+                }
+            }
+        }
+        else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+            const re = x.realPart();
+            const im = x.imagPart();
+            retval = sin(re)
+                .times(cosh(im))
+                .plus(cos(re).times(sinh(im)).i());
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.SIN, [x]);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the tangent of an expression.
+ *
+ * Tangent is an odd function: `tan(-x)` automatically simplifies to `-tan(x)`.
+ * Returns `0` for all integer multiples of π.
+ * Inverse trig compositions are resolved:
+ * - `tan(atan(x))` returns `x`
+ * - `tan(asin(x))` returns `x/sqrt(1 − x²)`
+ * - `tan(acos(x))` returns `sqrt(1 − x²)/x`
+ *
+ * @param x - The angle in radians.
+ * @returns The tangent of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞` or an odd multiple of `π/2`.
+ *
+ * @example
+ * ```ts
+ * tan(0).text()             // "0"
+ * tan('pi').text()          // "0"
+ * tan('pi/4').text()        // "1"
+ *
+ * // Symbolic
+ * tan('x').text()           // "tan(x)"
+ * ```
+ */
+function tan(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // tan(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    // tan is an odd function: tan(-x) = -tan(x)
+    if (x.sign() === -1 && !x.isNUM()) {
+        return tan(x.neg()).neg();
+    }
+    const m = Math.abs(+x.getMultiplier());
+    if (m === 1 && x.isFunction(constants_1.ATAN)) {
+        retval = x.getArguments()[0].times(x.sign());
+    }
+    else if (m === 1 && x.isFunction(constants_1.ASIN)) {
+        const [num, den] = argNumDen(x);
+        retval = num.div((0, math_1.sqrt)(den.sq().minus(num.sq()))).times(x.sign());
+    }
+    else if (m === 1 && x.isFunction(constants_1.ACOS)) {
+        const [num, den] = argNumDen(x);
+        retval = (0, math_1.sqrt)(den.sq().minus(num.sq())).div(num).times(x.sign());
+    }
+    else {
+        const piDenominator = toPiValue(x).getMultiplier().div(Rational_1.Rational.PI).denominator;
+        // If it's a multiple of pi or zero
+        if (piDenominator === 1n || x.isZero()) {
+            retval = (0, shortcuts_1.zero)();
+        }
+        // Check for multiplier of pi/2 and throw if true
+        else if (piDenominator === 2n) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('tanUndefined'));
+        }
+        else if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().tan());
+        }
+        else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+            const dblRe = x.realPart().times(2);
+            const dblIm = x.imagPart().times(2);
+            const d = cos(dblRe).plus(cosh(dblIm));
+            retval = sin(dblRe).div(d).plus(sinh(dblIm).div(d).i());
+        }
+        else {
+            retval = sin(x).div(cos(x));
+            if (retval.hasFunction(constants_1.COS)) {
+                retval = Expression_1.Expression.toFunction(constants_1.TAN, [x]);
+            }
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the secant of an expression: `sec(x) = 1/cos(x)`.
+ *
+ * Returns exact values at well-known angles by inverting the result of {@link cos}.
+ *
+ * @param x - The angle in radians.
+ * @returns The secant of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞` or an odd multiple of `π/2` (where `cos(x) = 0`).
+ *
+ * @example
+ * ```ts
+ * sec(0).text()             // "1"
+ * sec('pi').text()          // "-1"
+ * sec('pi/3').text()        // "2"
+ * sec('pi/4').text()        // "sqrt(2)"
+ *
+ * // Symbolic
+ * sec('x').text()           // "sec(x)"
+ * ```
+ */
+function sec(x) {
+    x = Expression_1.Expression.create(x);
+    // sec(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        const a = cos(re);
+        const b = cosh(im);
+        const c = sin(re);
+        const d = sinh(im);
+        const e = a.sq().times(b.sq()).plus(c.sq().times(d.sq()));
+        retval = a.times(b).div(e).plus(c.times(d).div(e).i());
+    }
+    else {
+        // sec(n*pi/2) is undefined
+        const cosVal = cos(x);
+        if (cosVal.isZero()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('secUndefined'));
+        }
+        retval = cosVal.invert();
+        if (retval.hasFunction(constants_1.COS)) {
+            retval = Expression_1.Expression.toFunction(constants_1.SEC, [x]);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the cosecant of an expression: `csc(x) = 1/sin(x)`.
+ *
+ * Returns exact values at well-known angles by inverting the result of {@link sin}.
+ *
+ * @param x - The angle in radians.
+ * @returns The cosecant of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞` or an integer multiple of `π` (where `sin(x) = 0`).
+ *
+ * @example
+ * ```ts
+ * csc('pi/2').text()        // "1"
+ * csc('pi/6').text()        // "2"
+ * csc('pi/4').text()        // "sqrt(2)"
+ *
+ * // Symbolic
+ * csc('x').text()           // "csc(x)"
+ * ```
+ */
+function csc(x) {
+    x = Expression_1.Expression.create(x);
+    // csc(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        const a = sin(re);
+        const b = cosh(im);
+        const c = cos(re);
+        const d = sinh(im);
+        const e = a.sq().times(b.sq()).plus(c.sq().times(d.sq()));
+        retval = a.times(b).div(e).minus(c.times(d).div(e).i());
+    }
+    else {
+        // csc(n*pi) is undefined
+        const sinVal = sin(x);
+        if (sinVal.isZero()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('cscUndefined'));
+        }
+        retval = sinVal.invert();
+        if (retval.hasFunction(constants_1.SIN)) {
+            retval = Expression_1.Expression.toFunction(constants_1.CSC, [x]);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the cotangent of an expression: `cot(x) = cos(x)/sin(x)`.
+ *
+ * Returns exact values at well-known angles by dividing {@link cos} by {@link sin}.
+ *
+ * @param x - The angle in radians.
+ * @returns The cotangent of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞` or an integer multiple of `π` (where `sin(x) = 0`).
+ *
+ * @example
+ * ```ts
+ * cot('pi/4').text()        // "1"
+ * cot('pi/3').text()        // "1/3*sqrt(3)"
+ *
+ * // Symbolic
+ * cot('x').text()           // "cot(x)"
+ * ```
+ */
+function cot(x) {
+    x = Expression_1.Expression.create(x);
+    // cot(±∞) is undefined
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        const a = sin(re);
+        const b = cos(re);
+        const c = sinh(im.times((0, shortcuts_1.two)()));
+        const d = cosh(im.times((0, shortcuts_1.two)()));
+        const e = cos(re.times((0, shortcuts_1.two)()));
+        const denom = d.minus(e);
+        retval = a.times(b).times((0, shortcuts_1.two)()).div(denom).plus(c.neg().div(denom).i());
+    }
+    else {
+        // cot(n*pi) is undefined
+        const sinVal = sin(x);
+        if (sinVal.isZero()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('cotUndefined'));
+        }
+        retval = cos(x).div(sinVal);
+        if (retval.hasFunction(constants_1.COS)) {
+            retval = Expression_1.Expression.toFunction(constants_1.COT, [x]);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the arccosine (inverse cosine) of an expression.
+ *
+ * Returns exact symbolic values involving π for well-known inputs:
+ * `0 → π/2`, `1/2 → π/3`, `1/√2 → π/4`, `√3/2 → π/6`, `1 → 0`.
+ * Uses the identity `acos(-x) = π − acos(x)` for negative arguments.
+ *
+ * For numeric inputs outside `[-1, 1]`, returns a complex result via
+ * `π/2 + asin(|x|)` with the appropriate sign adjustment.
+ *
+ * @param x - The input expression (domain `[-1, 1]` for real results).
+ * @returns The arccosine of `x` in radians.
+ * @throws {@link core!UndefinedError} If `x` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * acos(1).text()                    // "0"
+ * acos(0).text()                    // "1/2*pi"
+ * acos('1/2').text()                // "1/3*pi"
+ * acos('sqrt(2)^(-1)').text()       // "1/4*pi"
+ * acos(-1).text()                   // "pi"
+ *
+ * // Symbolic
+ * acos('x').text()                  // "acos(x)"
+ * ```
+ */
+function acos(x) {
+    x = Expression_1.Expression.create(x);
+    // acos(±∞) is undefined (domain is [-1, 1])
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        // Becomes complex between [-1, 1]
+        if (x.lt(-1) || x.gt(1)) {
+            const sgn = x.sign();
+            const halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+            let asinX = asin(x.abs());
+            if (sgn === 1) {
+                asinX = asinX.neg();
+            }
+            retval = halfPi.plus(asinX);
+        }
+        else {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().acos());
+        }
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const i = Expression_1.Expression.Img();
+        const a = (0, math_1.sqrt)((0, shortcuts_1.one)().minus(x.pow((0, shortcuts_1.two)())));
+        const b = i.times(x);
+        // Use formula: pi/2 - asin(x)
+        retval = Expression_1.Expression.Pi()
+            .div((0, shortcuts_1.two)())
+            .minus(i.times((0, math_2.log)(a.minus(b))))
+            .expand();
+    }
+    else if (!x.isComplex()) {
+        // Known values lookup using structural equality
+        const knownValues = [
+            [(0, shortcuts_1.zero)(), Expression_1.Expression.Pi().div((0, shortcuts_1.two)())],
+            [(0, shortcuts_1.one)().div((0, shortcuts_1.two)()), Expression_1.Expression.Pi().div((0, shortcuts_1.three)())],
+            [(0, shortcuts_1.one)().div((0, math_1.sqrt)((0, shortcuts_1.two)())), Expression_1.Expression.Pi().div((0, shortcuts_1.four)())],
+            [(0, math_1.sqrt)((0, shortcuts_1.three)()).div((0, shortcuts_1.two)()), Expression_1.Expression.Pi().div((0, shortcuts_1.six)())],
+            [(0, shortcuts_1.one)(), (0, shortcuts_1.zero)()],
+        ];
+        const absX = x.abs();
+        for (const [value, result] of knownValues) {
+            if (absX.eq(value)) {
+                // acos(-x) = π - acos(x)
+                retval = x.sign() === -1 ? Expression_1.Expression.Pi().minus(result) : result;
+                break;
+            }
+        }
+    }
+    if (retval === undefined) {
+        retval = Expression_1.Expression.toFunction(constants_1.ACOS, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the arcsine (inverse sine) of an expression.
+ *
+ * Returns exact symbolic values involving π for well-known inputs:
+ * `0 → 0`, `1/2 → π/6`, `1/√2 → π/4`, `√3/2 → π/3`, `1 → π/2`.
+ * Uses the identity `asin(-x) = -asin(x)` for negative arguments.
+ *
+ * For numeric inputs outside `[-1, 1]`, returns a complex result.
+ *
+ * @param x - The input expression (domain `[-1, 1]` for real results).
+ * @returns The arcsine of `x` in radians.
+ * @throws {@link core!UndefinedError} If `x` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * asin(0).text()                    // "0"
+ * asin(1).text()                    // "1/2*pi"
+ * asin('1/2').text()                // "1/6*pi"
+ * asin('sqrt(2)^(-1)').text()       // "1/4*pi"
+ *
+ * // Symbolic
+ * asin('x').text()                  // "asin(x)"
+ * ```
+ */
+function asin(x) {
+    x = Expression_1.Expression.create(x);
+    // asin(±∞) is undefined (domain is [-1, 1])
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        // asin has a domain of -1 to 1
+        if (x.lt((0, shortcuts_1.minusOne)()) || x.gt((0, shortcuts_1.one)())) {
+            const sgn = x.sign();
+            x = x.abs();
+            const xSqrMin1 = (0, math_1.sqrt)(x.sq().minus((0, shortcuts_1.one)()));
+            let halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+            let i = Expression_1.Expression.Img();
+            if (sgn === -1) {
+                halfPi = halfPi.neg();
+            }
+            else {
+                i = i.neg();
+            }
+            retval = halfPi.plus(i.times((0, math_2.log)(x.plus(xSqrMin1))));
+        }
+        else {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().asin());
+        }
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const i = Expression_1.Expression.Img();
+        const a = (0, math_1.sqrt)((0, shortcuts_1.one)().minus(x.pow((0, shortcuts_1.two)())));
+        const b = i.times(x);
+        retval = i.times((0, math_2.log)(a.minus(b))).expand();
+    }
+    else if (!x.isComplex()) {
+        // Known values lookup using structural equality
+        const knownValues = [
+            [(0, shortcuts_1.zero)(), (0, shortcuts_1.zero)()],
+            [(0, shortcuts_1.one)().div((0, shortcuts_1.two)()), Expression_1.Expression.Pi().div((0, shortcuts_1.six)())],
+            [(0, shortcuts_1.one)().div((0, math_1.sqrt)((0, shortcuts_1.two)())), Expression_1.Expression.Pi().div((0, shortcuts_1.four)())],
+            [(0, math_1.sqrt)((0, shortcuts_1.three)()).div((0, shortcuts_1.two)()), Expression_1.Expression.Pi().div((0, shortcuts_1.three)())],
+            [(0, shortcuts_1.one)(), Expression_1.Expression.Pi().div((0, shortcuts_1.two)())],
+        ];
+        const absX = x.abs();
+        for (const [value, result] of knownValues) {
+            if (absX.eq(value)) {
+                // asin(-x) = -asin(x)
+                retval = x.sign() === -1 ? result.neg() : result;
+                break;
+            }
+        }
+    }
+    if (retval === undefined) {
+        retval = Expression_1.Expression.toFunction(constants_1.ASIN, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the arctangent (inverse tangent) of an expression.
+ *
+ * Returns exact symbolic values involving π for well-known inputs:
+ * `0 → 0`, `1/√3 → π/6`, `1 → π/4`, `√3 → π/3`.
+ * Uses the identity `atan(-x) = -atan(x)` for negative arguments.
+ *
+ * At infinity: `atan(+∞) = π/2`, `atan(−∞) = −π/2`.
+ *
+ * @param x - The input expression.
+ * @returns The arctangent of `x` in radians.
+ *
+ * @example
+ * ```ts
+ * atan(0).text()              // "0"
+ * atan(1).text()              // "1/4*pi"
+ * atan('sqrt(3)').text()      // "1/3*pi"
+ *
+ * // Symbolic
+ * atan('x').text()            // "atan(x)"
+ * ```
+ */
+function atan(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // atan(∞) = π/2, atan(-∞) = -π/2
+    if (x.isPosInf() || x.isNegInf()) {
+        const halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+        return x.isNegInf() ? halfPi.neg() : halfPi;
+    }
+    if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().atan());
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const i = Expression_1.Expression.Img();
+        const a = (0, math_2.log)(i.minus(x).div(i.plus(x)));
+        retval = i.neg().div((0, shortcuts_1.two)()).times(a).expand();
+    }
+    else if (!x.isComplex()) {
+        // Known values lookup using structural equality
+        const knownValues = [
+            [(0, shortcuts_1.zero)(), (0, shortcuts_1.zero)()],
+            [(0, math_1.sqrt)((0, shortcuts_1.three)()).invert(), Expression_1.Expression.Pi().div((0, shortcuts_1.six)())],
+            [(0, shortcuts_1.one)(), Expression_1.Expression.Pi().div((0, shortcuts_1.four)())],
+            [(0, math_1.sqrt)((0, shortcuts_1.three)()), Expression_1.Expression.Pi().div((0, shortcuts_1.three)())],
+        ];
+        const absX = x.abs();
+        for (const [value, result] of knownValues) {
+            if (absX.eq(value)) {
+                // atan(-x) = -atan(x)
+                retval = x.sign() === -1 ? result.neg() : result;
+                break;
+            }
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ATAN, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the arcsecant (inverse secant) of an expression: `asec(x) = acos(1/x)`.
+ *
+ * At infinity: `asec(±∞) = π/2`.
+ *
+ * @param x - The input expression (domain `|x| ≥ 1` for real results).
+ * @returns The arcsecant of `x` in radians.
+ *
+ * @example
+ * ```ts
+ * asec(1).text()       // "0"
+ * asec(2).text()       // "1/3*pi"
+ *
+ * // Symbolic
+ * asec('x').text()     // "asec(x)"
+ * ```
+ */
+function asec(x) {
+    x = Expression_1.Expression.create(x);
+    // asec(±∞) = π/2 (since 1/∞ → 0, and acos(0) = π/2)
+    if (x.isPosInf() || x.isNegInf()) {
+        return Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+    }
+    const retval = acos(x.invert());
+    // Check if it's just an inverted acos
+    if (retval.isFunction(constants_1.ACOS) && retval.getArguments()[0].eq(x.invert())) {
+        return Expression_1.Expression.toFunction(constants_1.ASEC, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the arccosecant (inverse cosecant) of an expression: `acsc(x) = asin(1/x)`.
+ *
+ * At infinity: `acsc(±∞) = 0`.
+ *
+ * @param x - The input expression (domain `|x| ≥ 1` for real results).
+ * @returns The arccosecant of `x` in radians.
+ *
+ * @example
+ * ```ts
+ * acsc(1).text()       // "1/2*pi"
+ * acsc(2).text()       // "1/6*pi"
+ *
+ * // Symbolic
+ * acsc('x').text()     // "acsc(x)"
+ * ```
+ */
+function acsc(x) {
+    x = Expression_1.Expression.create(x);
+    // acsc(±∞) = 0 (since 1/∞ → 0, and asin(0) = 0)
+    if (x.isPosInf() || x.isNegInf()) {
+        return (0, shortcuts_1.zero)();
+    }
+    const retval = asin(x.invert());
+    // Check if it's just an inverted acos
+    if (retval.isFunction(constants_1.ASIN) && retval.getArguments()[0].eq(x.invert())) {
+        return Expression_1.Expression.toFunction(constants_1.ACSC, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the arccotangent (inverse cotangent) of an expression: `acot(x) = atan(1/x)`.
+ *
+ * At infinity: `acot(+∞) = 0`, `acot(−∞) = π`.
+ *
+ * @param x - The input expression.
+ * @returns The arccotangent of `x` in radians.
+ *
+ * @example
+ * ```ts
+ * acot(1).text()       // "1/4*pi"
+ *
+ * // Symbolic
+ * acot('x').text()     // "acot(x)"
+ * ```
+ */
+function acot(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // The real principal branch of acot is (0, π), with the endpoint limits
+    // acot(∞) = 0 and acot(-∞) = π.
+    if (x.isPosInf() || x.isNegInf()) {
+        retval = x.isNegInf() ? Expression_1.Expression.Pi() : (0, shortcuts_1.zero)();
+    }
+    else if (x.isZero()) {
+        retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+    }
+    else {
+        retval = atan(x.invert());
+        if (retval.isFunction(constants_1.ATAN) && retval.getArguments()[0].eq(x.invert())) {
+            retval = Expression_1.Expression.toFunction(constants_1.ACOT, [x]);
+        }
+        else if (x.isNUM() && x.sign() === -1) {
+            retval = Expression_1.Expression.Pi().plus(retval);
+        }
+    }
+    return retval;
+}
+/**
+ * Computes the two-argument arctangent `atan2(y, x)`, which returns the angle
+ * in radians between the positive x-axis and the point `(x, y)`.
+ *
+ * Unlike {@link atan}, `atan2` correctly handles all four quadrants and returns
+ * values in the range `(−π, π]`. Returns exact multiples of π where possible.
+ *
+ * @param y - The y-coordinate.
+ * @param x - The x-coordinate.
+ * @returns The angle in radians.
+ * @throws {@link core!UndefinedError} If both `x` and `y` are zero, or both are `±∞`.
+ *
+ * @see https://en.wikipedia.org/wiki/Atan2
+ *
+ * @example
+ * ```ts
+ * atan2(1, 1).text()       // "1/4*pi"
+ * atan2(0, 1).text()       // "0"
+ * atan2(1, 0).text()       // "1/2*pi"
+ * atan2(-1, 0).text()      // "-1/2*pi"
+ *
+ * // Symbolic
+ * atan2('y', 'x').text()   // "atan2(y, x)"
+ * ```
+ */
+function atan2(y, x) {
+    x = Expression_1.Expression.create(x);
+    y = Expression_1.Expression.create(y);
+    if (x.isZero() && y.isZero()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('atan2Undefined'));
+    }
+    // atan2(±∞, ±∞) is undefined
+    if ((x.isPosInf() || x.isNegInf()) && (y.isPosInf() || y.isNegInf())) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('atan2Undefined'));
+    }
+    // atan2(y, ∞) = 0, atan2(y, -∞) = π or -π depending on sign of y
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            return y.sign() === -1 ? Expression_1.Expression.Pi().neg() : Expression_1.Expression.Pi();
+        }
+        return (0, shortcuts_1.zero)();
+    }
+    // atan2(∞, x) = π/2, atan2(-∞, x) = -π/2
+    if (y.isPosInf() || y.isNegInf()) {
+        const halfPi = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+        return y.isNegInf() ? halfPi.neg() : halfPi;
+    }
+    let retval;
+    if (x.isNUM() && y.isNUM()) {
+        // Since it relies on our implementation of atan, we don't need to check for Settings.EVALUATE
+        const b = y.getMultiplier();
+        const a = x.getMultiplier();
+        if (a.gt((0, shortcuts_1.zero)())) {
+            retval = atan(y.div(x));
+        }
+        else if (a.lt('0') && b.gte('0')) {
+            retval = atan(y.div(x)).plus(Expression_1.Expression.Pi());
+        }
+        else if (a.lt('0') && b.lt('0')) {
+            retval = atan(y.div(x)).plus(Expression_1.Expression.Pi().neg());
+        }
+        else if (a.eq('0') && b.gt((0, shortcuts_1.zero)())) {
+            retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)());
+        }
+        else {
+            retval = Expression_1.Expression.Pi().neg().div((0, shortcuts_1.two)());
+        }
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.ATAN2, [y, x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic cosine of an expression.
+ *
+ * - `cosh(0) = 1`
+ * - `cosh(±∞) = +∞`
+ * - For complex inputs: `cosh(a + bi) = cosh(a)·cos(b) + i·sinh(a)·sin(b)`
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic cosine of `x`.
+ *
+ * @example
+ * ```ts
+ * cosh(0).text()       // "1"
+ *
+ * // Symbolic
+ * cosh('x').text()     // "cosh(x)"
+ * ```
+ */
+function cosh(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // cosh(±∞) = ∞
+    if (x.isPosInf() || x.isNegInf()) {
+        return Expression_1.Expression.Inf();
+    }
+    // cosh(0) = 1
+    if (x.isZero()) {
+        retval = (0, shortcuts_1.one)();
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().cosh());
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        retval = cosh(re)
+            .times(cos(im))
+            .plus(sinh(re).times(sin(im)).i());
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.COSH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic sine of an expression.
+ *
+ * - `sinh(0) = 0`
+ * - `sinh(+∞) = +∞`, `sinh(−∞) = −∞`
+ * - For complex inputs: `sinh(a + bi) = sinh(a)·cos(b) + i·cosh(a)·sin(b)`
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic sine of `x`.
+ *
+ * @example
+ * ```ts
+ * sinh(0).text()       // "0"
+ *
+ * // Symbolic
+ * sinh('x').text()     // "sinh(x)"
+ * ```
+ */
+function sinh(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // sinh(∞) = ∞, sinh(-∞) = -∞
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    // sinh(0) = 0
+    if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().sinh());
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        retval = sinh(re)
+            .times(cos(im))
+            .plus(cosh(re).times(sin(im)).i());
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.SINH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic tangent of an expression.
+ *
+ * - `tanh(0) = 0`
+ * - `tanh(+∞) = 1`, `tanh(−∞) = −1`
+ * - For complex inputs, uses the identity `tanh(z) = sinh(z)/cosh(z)` with
+ *   component-wise evaluation.
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic tangent of `x`.
+ *
+ * @example
+ * ```ts
+ * tanh(0).text()       // "0"
+ *
+ * // Symbolic
+ * tanh('x').text()     // "tanh(x)"
+ * ```
+ */
+function tanh(x) {
+    x = Expression_1.Expression.create(x);
+    let retval;
+    // tanh(∞) = 1, tanh(-∞) = -1
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? (0, shortcuts_1.one)().neg() : (0, shortcuts_1.one)();
+    }
+    // tanh(0) = 0
+    if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isNUM()) {
+        retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().tanh());
+    }
+    else if (Settings_1.Settings.EVALUATE && x.isComplex()) {
+        const re = x.realPart();
+        const im = x.imagPart();
+        const num = sinh(re)
+            .times(cos(im))
+            .plus(cosh(re).times(sin(im)).i());
+        const den = cosh(re)
+            .times(cos(im))
+            .plus(sinh(re).times(sin(im)).i());
+        retval = num.div(den);
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(constants_1.TANH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic secant of an expression: `sech(x) = 1/cosh(x)`.
+ *
+ * - `sech(0) = 1`
+ * - `sech(±∞) = 0`
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic secant of `x`.
+ *
+ * @example
+ * ```ts
+ * sech(0).text()       // "1"
+ *
+ * // Symbolic
+ * sech('x').text()     // "sech(x)"
+ * ```
+ */
+function sech(x) {
+    x = Expression_1.Expression.create(x);
+    // sech(±∞) = 0
+    if (x.isPosInf() || x.isNegInf()) {
+        return (0, shortcuts_1.zero)();
+    }
+    let retval = (0, shortcuts_1.one)().div(cosh(x));
+    if (retval.hasFunction(constants_1.COSH)) {
+        retval = Expression_1.Expression.toFunction(constants_1.SECH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic cosecant of an expression: `csch(x) = 1/sinh(x)`.
+ *
+ * - `csch(±∞) = 0`
+ * - `csch(0)` is undefined.
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic cosecant of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `0`.
+ *
+ * @example
+ * ```ts
+ * // Symbolic
+ * csch('x').text()     // "csch(x)"
+ * ```
+ */
+function csch(x) {
+    x = Expression_1.Expression.create(x);
+    // csch(±∞) = 0
+    if (x.isPosInf() || x.isNegInf()) {
+        return (0, shortcuts_1.zero)();
+    }
+    // csch(0) is undefined
+    if (x.isZero()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('cschUndefined'));
+    }
+    let retval = (0, shortcuts_1.one)().div(sinh(x));
+    if (retval.hasFunction(constants_1.SINH)) {
+        retval = Expression_1.Expression.toFunction(constants_1.CSCH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the hyperbolic cotangent of an expression: `coth(x) = 1/tanh(x)`.
+ *
+ * - `coth(+∞) = 1`, `coth(−∞) = −1`
+ * - `coth(0)` is undefined.
+ *
+ * @param x - The input expression.
+ * @returns The hyperbolic cotangent of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `0`.
+ *
+ * @example
+ * ```ts
+ * // Symbolic
+ * coth('x').text()     // "coth(x)"
+ * ```
+ */
+function coth(x) {
+    x = Expression_1.Expression.create(x);
+    // coth(∞) = 1, coth(-∞) = -1
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? (0, shortcuts_1.one)().neg() : (0, shortcuts_1.one)();
+    }
+    // coth(0) is undefined
+    if (x.isZero()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('cothUndefined'));
+    }
+    let retval = (0, shortcuts_1.one)().div(tanh(x));
+    if (retval.hasFunction(constants_1.TANH)) {
+        retval = Expression_1.Expression.toFunction(constants_1.COTH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic cosine of an expression.
+ *
+ * - `acosh(1) = 0`
+ * - `acosh(0) = iπ/2`
+ * - `acosh(+∞) = +∞`
+ * - For inputs less than 1, returns a complex result via `log(x + sqrt(x²−1))`.
+ *
+ * @param x - The input expression (domain `[1, ∞)` for real results).
+ * @returns The inverse hyperbolic cosine of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `−∞`.
+ *
+ * @example
+ * ```ts
+ * acosh(1).text()       // "0"
+ *
+ * // Symbolic
+ * acosh('x').text()     // "acosh(x)"
+ * ```
+ */
+function acosh(x) {
+    x = Expression_1.Expression.create(x);
+    // acosh(∞) = ∞, acosh(-∞) is undefined (domain is [1, ∞))
+    if (x.isPosInf() || x.isNegInf()) {
+        if (x.isNegInf()) {
+            throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+        }
+        return Expression_1.Expression.Inf();
+    }
+    // The domain is [1, infinity]
+    let retval;
+    if (x.isOne()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isZero()) {
+        // acosh(0) = i*pi/2
+        retval = Expression_1.Expression.Pi().div((0, shortcuts_1.two)()).times(Expression_1.Expression.Img());
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex() || x.lt('1')) {
+            const a = (0, math_1.sqrt)(x.plus((0, shortcuts_1.one)()));
+            const b = (0, math_1.sqrt)(x.minus((0, shortcuts_1.one)()));
+            const c = x.plus(a.times(b));
+            retval = (0, math_2.log)(c);
+        }
+        else {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().acosh());
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ACOSH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic sine of an expression.
+ *
+ * - `asinh(0) = 0`
+ * - `asinh(+∞) = +∞`, `asinh(−∞) = −∞`
+ * - For complex inputs, uses `log(x + sqrt(x² + 1))`.
+ *
+ * @param x - The input expression.
+ * @returns The inverse hyperbolic sine of `x`.
+ *
+ * @example
+ * ```ts
+ * asinh(0).text()       // "0"
+ *
+ * // Symbolic
+ * asinh('x').text()     // "asinh(x)"
+ * ```
+ */
+function asinh(x) {
+    x = Expression_1.Expression.create(x);
+    // asinh(∞) = ∞, asinh(-∞) = -∞
+    if (x.isPosInf() || x.isNegInf()) {
+        return x.isNegInf() ? Expression_1.Expression.NegInf() : Expression_1.Expression.Inf();
+    }
+    let retval;
+    if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex()) {
+            retval = (0, math_2.log)(x.plus((0, math_1.sqrt)(x.sq().plus((0, shortcuts_1.one)()))));
+        }
+        else {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().asinh());
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ASINH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic tangent of an expression.
+ *
+ * - `atanh(0) = 0`
+ * - For inputs outside `(-1, 1)` or complex inputs, uses the identity
+ *   `atanh(z) = (1/2)·ln((1 + z)/(1 − z))`.
+ *
+ * @param x - The input expression (domain `(-1, 1)` for real results).
+ * @returns The inverse hyperbolic tangent of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞` or exactly `1`.
+ *
+ * @example
+ * ```ts
+ * atanh(0).text()       // "0"
+ *
+ * // Symbolic
+ * atanh('x').text()     // "atanh(x)"
+ * ```
+ */
+function atanh(x) {
+    x = Expression_1.Expression.create(x);
+    // atanh(±∞) is undefined (domain is (-1, 1))
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (x.isZero()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    else if (x.isOne()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('atanhUndefined'));
+    }
+    else if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex() || x.lt((0, shortcuts_1.minusOne)()) || x.gt((0, shortcuts_1.one)())) {
+            //atanh(z) = (1/2) * ln((1 + z) / (1 - z))
+            retval = (0, math_2.log)((0, shortcuts_1.one)().plus(x).div((0, shortcuts_1.one)().minus(x)))
+                .div((0, shortcuts_1.two)())
+                .expand();
+        }
+        else {
+            retval = Expression_1.Expression.Number(x.getMultiplier().toDecimal().atanh());
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ATANH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic secant of an expression: `asech(x) = acosh(1/x)`.
+ *
+ * For real evaluation, uses the identity `asech(x) = ln((1 + sqrt(1/x² − 1))/x)`.
+ *
+ * @param x - The input expression (domain `(0, 1]` for real results).
+ * @returns The inverse hyperbolic secant of `x`.
+ * @throws {@link core!UndefinedError} If `x` is `±∞`.
+ *
+ * @example
+ * ```ts
+ * asech(1).text()       // "0"
+ *
+ * // Symbolic
+ * asech('x').text()     // "asech(x)"
+ * ```
+ */
+function asech(x) {
+    x = Expression_1.Expression.create(x);
+    // asech(±∞) is undefined (domain is (0, 1])
+    if (x.isPosInf() || x.isNegInf()) {
+        throw new errors_1.UndefinedError((0, errors_1.message)('undefinedValue'));
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex()) {
+            retval = acosh(x.invert());
+        }
+        else {
+            const a = (0, shortcuts_1.one)().div(x);
+            const b = (0, math_1.sqrt)((0, shortcuts_1.one)().div(x.sq()).minus((0, shortcuts_1.one)()));
+            retval = (0, math_2.log)(b.plus(a));
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ASECH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic cosecant of an expression: `acsch(x) = asinh(1/x)`.
+ *
+ * - `acsch(±∞) = 0`
+ * - For real evaluation, uses the identity `acsch(x) = ln((1 + sqrt(1/x² + 1))/x)`.
+ *
+ * @param x - The input expression.
+ * @returns The inverse hyperbolic cosecant of `x`.
+ *
+ * @example
+ * ```ts
+ * // Symbolic
+ * acsch('x').text()     // "acsch(x)"
+ * ```
+ */
+function acsch(x) {
+    x = Expression_1.Expression.create(x);
+    // acsch(±∞) = 0
+    if (x.isPosInf() || x.isNegInf()) {
+        return (0, shortcuts_1.zero)();
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex()) {
+            retval = asinh(x.invert());
+        }
+        else {
+            const a = (0, shortcuts_1.one)().div(x);
+            const b = (0, math_1.sqrt)((0, shortcuts_1.one)().div(x.sq()).plus((0, shortcuts_1.one)()));
+            retval = (0, math_2.log)(b.plus(a));
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ACSCH, [x]);
+    }
+    return retval;
+}
+/**
+ * Computes the inverse hyperbolic cotangent of an expression: `acoth(x) = atanh(1/x)`.
+ *
+ * - `acoth(±∞) = 0`
+ * - For real evaluation, uses the identity `acoth(x) = (1/2)·ln((x + 1)/(x − 1))`.
+ *
+ * @param x - The input expression (domain `|x| > 1` for real results).
+ * @returns The inverse hyperbolic cotangent of `x`.
+ *
+ * @example
+ * ```ts
+ * // Symbolic
+ * acoth('x').text()     // "acoth(x)"
+ * ```
+ */
+function acoth(x) {
+    x = Expression_1.Expression.create(x);
+    // acoth(±∞) = 0
+    if (x.isPosInf() || x.isNegInf()) {
+        return (0, shortcuts_1.zero)();
+    }
+    let retval;
+    if (Settings_1.Settings.EVALUATE) {
+        if (x.isComplex()) {
+            retval = atanh(x.invert());
+        }
+        else {
+            retval = (0, math_2.log)(x.plus((0, shortcuts_1.one)()).div(x.minus((0, shortcuts_1.one)())))
+                .div((0, shortcuts_1.two)())
+                .expand();
+        }
+    }
+    if (!retval) {
+        retval = Expression_1.Expression.toFunction(constants_1.ACOTH, [x]);
+    }
+    return retval;
+}