nerdamer 1.1.13 → 2.0.0-rc.1

package/output/math/trig.d.ts

@@ -0,0 +1,518 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+export { TRIG_FUNCTION_NAMES, COS, SIN, TAN, ASIN, ACOS, SEC, CSC, COT, ATAN, ASEC, ACSC, ACOT, ATAN2, SINH, COSH, TANH, SECH, CSCH, COTH, ACOSH, ASINH, ATANH, ASECH, ACSCH, ACOTH, TRIG, INVERSE_TRIG, HYPERBOLIC_TRIG, INVERSE_HYPERBOLIC_TRIG, } from '../core/classes/parser/constants';
+/**
+ * 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)"
+ * ```
+ */
+export declare function cos(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function sin(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function tan(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function sec(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function csc(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function cot(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acos(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function asin(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function atan(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function asec(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acsc(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acot(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function atan2(y: ExpressionInput, x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function cosh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function sinh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function tanh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function sech(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function csch(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function coth(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acosh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function asinh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function atanh(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function asech(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acsch(x: ExpressionInput): Expression;
+/**
+ * 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)"
+ * ```
+ */
+export declare function acoth(x: ExpressionInput): Expression;