nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/functions/bigint/primeFactor.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPrimeBig = isPrimeBig;
+exports.trialDivisionBig = trialDivisionBig;
+exports.pollardRhoBig = pollardRhoBig;
+exports.primeFactorsBig = primeFactorsBig;
+exports.primeFactorCounts = primeFactorCounts;
+exports.mergeFactors = mergeFactors;
+exports.getFactors = getFactors;
+const bigint_1 = require("./bigint");
+/**
+ * Calculates and array of prime factors
+ *
+ * @see https://stackoverflow.com/questions/39899072/how-can-i-find-the-prime-factors-of-an-integer-in-javascript by @TheChiporpoise
+ * @param num
+ * @returns
+ */
+// export function primeFactors(num: bigint, toNumbers: true): { sign: number, factors: number[] };
+// export function primeFactors(num: bigint, toNumbers: false | void): { sign: number, factors: bigint[] };
+// export function primeFactors(num: bigint, toNumbers?: boolean | void) {
+// 	const factors: bigint[] = [];
+// 	const sgn = sign(num);
+// 	num = abs(num)
+// 	/* since 2 is the only even prime, it's easier to factor it out
+// 	 * separately from the odd factor loop (for loop doesn't need to
+// 	 * check whether or not to add 1 or 2 to f).
+// 	 * The condition is essentially checking if the number is even
+// 	 * (bitwise "&" operator compares the bits of 2 numbers in binary
+// 	 * and outputs a binary number with 1's where their digits are the
+// 	 * same and 0's where they differ. In this case it only checks if
+// 	 * the final digit for num in binary is 1, which would mean the
+// 	 * number is odd, in which case the output would be 1, which is
+// 	 * interpreted as true, otherwise the output will be 0, which is
+// 	 * interpreted as false. "!" returns the opposite boolean, so this
+// 	 * means that '!(num & 1)' is true when the num is not odd)
+// 	 */
+// 	while (!(num & 1n)) {
+// 		factors.push(2n);
+// 		num /= 2n;
+// 	}
+// 	// 'f*f <= num' is faster than 'f <= Math.sqrt(num)'
+// 	for (let f = 3n; f * f <= num; f += 2n) {
+// 		while (!(num % f)) { // remainder of 'num / f' isn't 0
+// 			factors.push(f);
+// 			num /= f;
+// 		}
+// 	}
+// 	/* if the number is already prime, then this adds it to factors so
+// 	 * an empty array isn't returned
+// 	 */
+// 	if (num !== 1n) {
+// 		factors.push(num);
+// 	}
+// 	return {
+// 		sign: sgn,
+// 		factors: toNumbers ? factors.map((n) => Number(n)) : factors
+// 	}
+// }
+// Miller-Rabin primality test
+function isPrimeBig(num) {
+    if (num < 2n) {
+        return false;
+    }
+    if (num === 2n || num === 3n) {
+        return true;
+    }
+    if (num % 2n === 0n) {
+        return false;
+    }
+    let r = 0n;
+    let d = num - 1n;
+    while (d % 2n === 0n) {
+        r++;
+        d /= 2n;
+    }
+    const modPow = (base, exp, mod) => {
+        let result = 1n;
+        base %= mod;
+        while (exp > 0n) {
+            if (exp % 2n === 1n) {
+                result = (result * base) % mod;
+            }
+            base = (base * base) % mod;
+            exp /= 2n;
+        }
+        return result;
+    };
+    // These witnesses are deterministic for every unsigned 64-bit integer. For larger
+    // BigInts they remain a stable probable-prime test rather than a randomized result.
+    const witnesses = num < 18446744073709551616n
+        ? [2n, 325n, 9375n, 28178n, 450775n, 9780504n, 1795265022n]
+        : [2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n];
+    for (const witness of witnesses) {
+        const a = witness % num;
+        if (a < 2n) {
+            continue;
+        }
+        let x = modPow(a, d, num);
+        if (x === 1n || x === num - 1n) {
+            continue;
+        }
+        let proceed = false;
+        for (let j = 0n; j < r - 1n; j++) {
+            x = (x * x) % num;
+            if (x === num - 1n) {
+                proceed = true;
+                break;
+            }
+        }
+        if (!proceed) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Fast prime factorization using trial division with optimizations
+ */
+function trialDivisionBig(n) {
+    if (n <= 1n) {
+        return [];
+    }
+    const factors = [];
+    // Handle factor of 2
+    while (n % 2n === 0n) {
+        factors.push(2n);
+        n /= 2n;
+    }
+    // Handle odd factors from 3 onwards
+    let i = 3n;
+    const sqrt = (num) => {
+        if (num < 2n) {
+            return num;
+        }
+        let x = num;
+        let y = (x + 1n) / 2n;
+        while (y < x) {
+            x = y;
+            y = (x + num / x) / 2n;
+        }
+        return x;
+    };
+    const limit = sqrt(n);
+    while (i <= limit) {
+        while (n % i === 0n) {
+            factors.push(i);
+            n /= i;
+        }
+        i += 2n; // Skip even numbers
+    }
+    // If n is still greater than 1, it's a prime factor
+    if (n > 1n) {
+        factors.push(n);
+    }
+    return factors;
+}
+/**
+ * Pollard's rho algorithm for faster factorization of large numbers
+ */
+function pollardRhoBig(n) {
+    if (n % 2n === 0n) {
+        return 2n;
+    }
+    let x = 2n;
+    let y = 2n;
+    let d = 1n;
+    const f = (val) => (val * val + 1n) % n;
+    const gcd = (a, b) => {
+        while (b !== 0n) {
+            [a, b] = [b, a % b];
+        }
+        return a;
+    };
+    while (d === 1n) {
+        x = f(x);
+        y = f(f(y));
+        d = gcd(x > y ? x - y : y - x, n);
+    }
+    return d === n ? 0n : d;
+}
+function primeFactorsBig(n, toNumbers) {
+    const sgn = (0, bigint_1.sign)(n);
+    n = (0, bigint_1.abs)(n);
+    const factors = [];
+    if (n === 1n || n === 2n || isPrimeBig(n)) {
+        factors.push(n);
+    }
+    else {
+        const factorize = (num) => {
+            if (num === 1n) {
+                return;
+            }
+            if (isPrimeBig(num)) {
+                factors.push(num);
+                return;
+            }
+            const divisor = pollardRhoBig(num);
+            if (divisor === 0n) {
+                // Fallback to trial division
+                const simple = trialDivisionBig(num);
+                factors.push(...simple);
+                return;
+            }
+            factorize(divisor);
+            factorize(num / divisor);
+        };
+        factorize(n);
+    }
+    factors.sort((a, b) => (a < b ? -1 : 1));
+    return {
+        sign: sgn,
+        factors: toNumbers ? factors.map(x => Number(x)) : factors,
+    };
+}
+/**
+ * Places the prime factors in an object and counts their occurrences
+ *
+ * @param n
+ */
+function primeFactorCounts(n) {
+    const counts = {};
+    const factors = primeFactorsBig(n).factors;
+    for (const factor of factors) {
+        const f = String(factor);
+        if (!(f in counts)) {
+            counts[f] = 1n;
+        }
+        else {
+            counts[f]++;
+        }
+    }
+    return counts;
+}
+/**
+ * Merges two factor counts into one object
+ *
+ * @param a
+ * @param b
+ */
+function mergeFactors(a, b) {
+    // Make a copy of a
+    const retval = Object.assign(a, {});
+    // Merge their counts
+    for (const factor in b) {
+        retval[factor] = factor in retval ? retval[factor] + b[factor] : b[factor];
+    }
+    return retval;
+}
+/**
+ * Gets prime factors that can be used to create a number. The number one is
+ * included since 1 * n is a possible combination.
+ *
+ * @param n The number for which the factors are being retrieved
+ * @returns
+ */
+function getFactors(n) {
+    const { sign: sgn, factors } = primeFactorsBig(BigInt(n), true);
+    // Add the one since 1 * p is a combination
+    factors.unshift(1);
+    if (sgn === -1) {
+        const l = factors.length;
+        for (let i = 0; i < l; i++) {
+            factors.push(-factors[i]);
+        }
+    }
+    return factors;
+}

package/output/core/functions/bigint/primes.d.ts

@@ -0,0 +1 @@
+export declare const PRIMES_100: bigint[];

package/output/core/functions/bigint/primes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIMES_100 = void 0;
+// prettier-ignore
+exports.PRIMES_100 = [
+    2n, 3n, 5n, 7n, 11n, 13n, 17n, 19n, 23n, 29n, 31n, 37n, 41n, 43n, 47n, 53n, 59n, 61n, 67n, 71n, 73n, 79n, 83n, 89n, 97n,
+    101n, 103n, 107n, 109n, 113n, 127n, 131n, 137n, 139n, 149n, 151n, 157n, 163n, 167n, 173n, 179n, 181n, 191n, 193n, 197n, 199n, 211n, 223n,
+    227n, 229n, 233n, 239n, 241n, 251n, 257n, 263n, 269n, 271n, 277n, 281n, 283n, 293n, 307n, 311n, 313n, 317n, 331n, 337n, 347n, 349n, 353n,
+    359n, 367n, 373n, 379n, 383n, 389n, 397n, 401n, 409n, 419n, 421n, 431n, 433n, 439n, 443n, 449n, 457n, 461n, 463n, 467n, 479n, 487n, 491n,
+    499n, 503n, 509n, 521n, 523n, 541n
+];

package/output/core/functions/build/definitions.d.ts

@@ -0,0 +1,12 @@
+import type { JsFunction } from '../../classes/parser/types';
+/**
+ * Numerical function implementations available to `buildFunction`.
+ *
+ * Every function body must either be self-contained or list each free function dependency
+ * by its registry name so `buildFunction` can serialize the complete implementation. Functions
+ * whose meaning depends on symbolic variables, structured entities, or complex-valued runtime
+ * objects are absent and are rejected by the compiler.
+ */
+export declare const definitions: {
+    [name: string]: [f: JsFunction, dependencies?: string[]];
+};

package/output/core/functions/build/definitions.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.definitions = void 0;
+const fresnelNumeric_1 = require("../fresnelNumeric");
+const numeric_1 = require("../numeric");
+/**
+ * Numerical function implementations available to `buildFunction`.
+ *
+ * Every function body must either be self-contained or list each free function dependency
+ * by its registry name so `buildFunction` can serialize the complete implementation. Functions
+ * whose meaning depends on symbolic variables, structured entities, or complex-valued runtime
+ * objects are absent and are rejected by the compiler.
+ */
+exports.definitions = {
+    // Trigonometric functions
+    cos: [x => Math.cos(x)],
+    sin: [x => Math.sin(x)],
+    tan: [x => Math.tan(x)],
+    sec: [x => 1 / Math.cos(x)],
+    csc: [x => (x === 0 ? NaN : 1 / Math.sin(x))],
+    cot: [x => (x === 0 ? NaN : 1 / Math.tan(x))],
+    acos: [x => Math.acos(x)],
+    asin: [x => Math.asin(x)],
+    atan: [x => Math.atan(x)],
+    asec: [x => Math.acos(1 / x)],
+    acsc: [x => Math.asin(1 / x)],
+    acot: [x => (x < 0 ? Math.PI + Math.atan(1 / x) : Math.atan(1 / x))],
+    atan2: [
+        (y, x) => (y === 0 && x === 0) || (!Number.isFinite(y) && !Number.isFinite(x))
+            ? NaN
+            : Math.atan2(y, x),
+    ],
+    // Hyperbolic functions
+    cosh: [x => Math.cosh(x)],
+    sinh: [x => Math.sinh(x)],
+    tanh: [x => Math.tanh(x)],
+    sech: [x => 1 / Math.cosh(x)],
+    csch: [x => (x === 0 ? NaN : 1 / Math.sinh(x))],
+    coth: [x => (x === 0 ? NaN : 1 / Math.tanh(x))],
+    acosh: [x => Math.acosh(x)],
+    asinh: [x => Math.asinh(x)],
+    atanh: [x => (x === 1 ? NaN : Math.atanh(x))],
+    asech: [x => (x === 0 ? NaN : Math.acosh(1 / x))],
+    acsch: [x => (x === 0 ? NaN : Math.asinh(1 / x))],
+    acoth: [x => Math.atanh(1 / x)],
+    // Scalar arithmetic and elementary functions
+    abs: [x => Math.abs(x)],
+    sqrt: [x => Math.sqrt(x)],
+    cbrt: [x => Math.cbrt(x)],
+    nthroot: [(x, n) => (n === 0 ? NaN : Math.pow(x, 1 / n))],
+    log: [
+        (x, base) => base === undefined
+            ? Math.log(x)
+            : base <= 0 || base === 1
+                ? NaN
+                : Math.log(x) / Math.log(base),
+    ],
+    exp: [x => Math.exp(x)],
+    hypot: [(a, b) => Math.hypot(a, b)],
+    round: [numeric_1.round, ['isInt']],
+    sign: [x => Math.sign(x)],
+    floor: [x => Math.floor(x)],
+    ceil: [x => Math.ceil(x)],
+    ceiling: [x => Math.ceil(x)],
+    trunc: [x => Math.trunc(x)],
+    mod: [numeric_1.mod],
+    modinv: [numeric_1.modInv, ['mod']],
+    max: [(...args) => Math.max(...args)],
+    min: [(...args) => Math.min(...args)],
+    avg: [(...args) => args.reduce((total, value) => total + value, 0) / args.length],
+    heaviside: [numeric_1.heaviside],
+    // Complex-component helpers are limited to real JavaScript-number inputs. This is
+    // faithful to buildFunction's scalar runtime function without pretending to provide
+    // a JavaScript-number representation for genuinely complex values.
+    realpart: [x => x],
+    imagpart: [() => 0],
+    arg: [x => (Number.isNaN(x) ? NaN : x < 0 ? Math.PI : 0)],
+    conjugate: [x => x],
+    polarform: [x => x],
+    rectform: [x => x],
+    csgn: [x => Math.sign(x)],
+    // Integer-valued helpers. Keep internal dependency names available because the
+    // emitted function bodies reference these identifiers directly.
+    isInt: [numeric_1.isInt],
+    GCD: [numeric_1.GCD],
+    gcd: [numeric_1.GCD],
+    LCM: [numeric_1.LCM, ['GCD']],
+    lcm: [numeric_1.LCM, ['GCD']],
+    modInv: [numeric_1.modInv, ['mod']],
+    isPrime: [numeric_1.isPrime],
+    isprime: [numeric_1.isPrime],
+    fib: [
+        x => {
+            let retval = NaN;
+            if (Number.isSafeInteger(x)) {
+                const isNegative = x < 0;
+                const index = Math.abs(x);
+                let a = 0;
+                let b = 1;
+                for (let i = 0; i < index; i++) {
+                    const next = a + b;
+                    a = b;
+                    b = next;
+                    if (!Number.isSafeInteger(a)) {
+                        break;
+                    }
+                }
+                if (Number.isSafeInteger(a)) {
+                    retval = isNegative && index % 2 === 0 ? -a : a;
+                }
+            }
+            return retval;
+        },
+    ],
+    fact: [numeric_1.factorial, ['isInt', 'gamma']],
+    factorial: [numeric_1.factorial, ['isInt', 'gamma']],
+    dfact: [numeric_1.doubleFactorial, ['isInt', 'gamma']],
+    // Special functions
+    erf: [numeric_1.erf, ['erfc']],
+    erfc: [numeric_1.erfc],
+    gammaLN: [numeric_1.gammaLN],
+    gamma: [numeric_1.gamma, ['gammaLN', 'isInt', 'factorial']],
+    sinc: [numeric_1.sinc],
+    Si: [numeric_1.Si],
+    Shi: [numeric_1.Shi],
+    Ci: [numeric_1.Ci],
+    Chi: [numeric_1.Chi],
+    Ei: [numeric_1.Ei],
+    Li: [numeric_1.Li],
+    fresnelIntegral: [fresnelNumeric_1.fresnelIntegral],
+    S: [fresnelNumeric_1.fresnelS, ['fresnelIntegral']],
+    C: [fresnelNumeric_1.fresnelC, ['fresnelIntegral']],
+};

package/output/core/functions/build/index.d.ts

@@ -0,0 +1,32 @@
+import type { ExpressionInput } from '../../types';
+/**
+ * Compiles an expression into a native JavaScript-number function for repeated evaluation.
+ *
+ * @remarks
+ * Function calls are linked to Nerdamer's internal numerical implementation registry, including
+ * any dependencies those implementations require. The compiler supports scalar JavaScript-number
+ * semantics rather than Nerdamer's full symbolic or structured object model. Symbolic-only
+ * operations such as indexed sums/products, solvers, and matrix operations are rejected if they
+ * remain in the expression at compilation time.
+ *
+ * `buildFunction` is the only Nerdamer runtime path that performs dynamic JavaScript code
+ * generation. Normal parsing, simplification, solving, evaluation, and symbolic manipulation do
+ * not use `eval()` or `new Function`. This compiler uses `new Function`, so it may be unavailable
+ * under a Content Security Policy that forbids dynamic JavaScript evaluation.
+ *
+ * When `argsArray` is omitted, free variables are sorted alphabetically.
+ *
+ * @param x - The expression being converted to a function.
+ * @param argsArray - Variable names in the positional order expected by the compiled function.
+ * @returns The compiled JavaScript-number function.
+ * @throws {@link core!UnsupportedOperationError} If the expression contains the imaginary unit or a
+ * function for which no faithful JavaScript-number implementation is registered.
+ *
+ * @example
+ * ```ts
+ * build('x-y')(9, 7);				// 2
+ * build('x-y', ['y', 'x'])(9, 7);	// -2
+ * build('erf(x)+2')(9)				// 3
+ * ```
+ */
+export declare function build(x: ExpressionInput, argsArray?: string[]): (...args: number[]) => number;

package/output/core/functions/build/index.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = build;
+const Expression_1 = require("../../classes/expression/Expression");
+const constants_1 = require("../../classes/parser/constants");
+const errors_1 = require("../../errors");
+const numeric_1 = require("../numeric");
+const definitions_1 = require("./definitions");
+/**
+ * Compiles an expression into a native JavaScript-number function for repeated evaluation.
+ *
+ * @remarks
+ * Function calls are linked to Nerdamer's internal numerical implementation registry, including
+ * any dependencies those implementations require. The compiler supports scalar JavaScript-number
+ * semantics rather than Nerdamer's full symbolic or structured object model. Symbolic-only
+ * operations such as indexed sums/products, solvers, and matrix operations are rejected if they
+ * remain in the expression at compilation time.
+ *
+ * `buildFunction` is the only Nerdamer runtime path that performs dynamic JavaScript code
+ * generation. Normal parsing, simplification, solving, evaluation, and symbolic manipulation do
+ * not use `eval()` or `new Function`. This compiler uses `new Function`, so it may be unavailable
+ * under a Content Security Policy that forbids dynamic JavaScript evaluation.
+ *
+ * When `argsArray` is omitted, free variables are sorted alphabetically.
+ *
+ * @param x - The expression being converted to a function.
+ * @param argsArray - Variable names in the positional order expected by the compiled function.
+ * @returns The compiled JavaScript-number function.
+ * @throws {@link core!UnsupportedOperationError} If the expression contains the imaginary unit or a
+ * function for which no faithful JavaScript-number implementation is registered.
+ *
+ * @example
+ * ```ts
+ * build('x-y')(9, 7);				// 2
+ * build('x-y', ['y', 'x'])(9, 7);	// -2
+ * build('erf(x)+2')(9)				// 3
+ * ```
+ */
+function build(x, argsArray) {
+    x = Expression_1.Expression.create(x);
+    if (x.hasVariable(Expression_1.Expression.imaginary)) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('buildFunctionComplexUnsupported'));
+    }
+    // Collect the constants such as e, pi, or any other constants defined by the functions.
+    const constants = collectConstants(x);
+    /**
+     * The body for the most part is just a expression. The function definitions get loaded
+     * from the numeric functions object.
+     */
+    const body = `${x.text({ wrapPow: true })};`
+        //The caret symbol gets replaced because it has an entirely different meaning to JavaScript
+        .replace(/\^/g, '**');
+    /**
+     * Collect the functions in the string and import their definitions. Basically for each
+     * function call in the expression a definition in the form const fn = ...; is added
+     */
+    const imports = [[], []];
+    x.functions().forEach((e) => {
+        importDeps(e, imports);
+    });
+    /**
+     * Compile the imports string
+     */
+    let compiledImports = '';
+    for (let i = 0; i < imports[0].length; i++) {
+        compiledImports += `var ${imports[0][i]} = ${imports[1][i]};\n`;
+    }
+    /**
+     * If no variables array is provided then it's generated;
+     */
+    const functionArgs = argsArray || x.variables().sort();
+    // Construction the function definition
+    const functionDef = `${constants}${compiledImports} return ${body}`;
+    return new Function(...functionArgs, functionDef);
+}
+/**
+ * Recursively collects functions and their dependencies.
+ *
+ * @param name - Function name emitted by the expression converter.
+ * @param imports - Ordered names and implementations that will be inserted into the function body.
+ * @param visiting - Function names on the current dependency path.
+ * @returns The same imports tuple after adding the requested definition and its dependencies.
+ */
+function importDeps(name, imports, visiting = new Set()) {
+    // Parentheses are represented internally as a function with an empty name. They are
+    // already valid JavaScript syntax and do not need a numerical implementation.
+    if (name === '') {
+        return imports;
+    }
+    const names = imports[0];
+    const fns = imports[1];
+    if (names.includes(name)) {
+        return imports;
+    }
+    const definition = definitions_1.definitions[name];
+    if (definition === undefined) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('buildFunctionUnsupportedFunction', { function: name }));
+    }
+    // Numerical definitions can depend on one another. Track the active dependency path so
+    // mutually recursive definitions cannot recurse forever while the function is compiled.
+    if (visiting.has(name)) {
+        return imports;
+    }
+    visiting.add(name);
+    const [f, deps] = definition;
+    if (deps !== undefined) {
+        for (const dep of deps) {
+            importDeps(dep, imports, visiting);
+        }
+    }
+    visiting.delete(name);
+    if (!names.includes(name)) {
+        names.push(name);
+        fns.push(f);
+    }
+    return imports;
+}
+function collectConstants(x) {
+    const EULER_GAMMA_IDENTIFIER = 'EULER_GAMMA';
+    const constants = [];
+    const nativeConstants = { [constants_1.PI_NAME]: Math.PI, [constants_1.E]: Math.E };
+    function setConstant(name, value) {
+        constants.push(`var ${name} = ${value};\n`);
+    }
+    // Add the constants pi and e
+    [constants_1.PI_NAME, constants_1.E].forEach(e => {
+        if (x.hasVariable(e)) {
+            setConstant(e, nativeConstants[e]);
+        }
+    });
+    // Add constants for special functions
+    if ([constants_1.CI, constants_1.CHI, constants_1.SI, constants_1.SHI, constants_1.LI, constants_1.EI].some(f => x.hasFunction(f, true))) {
+        setConstant(EULER_GAMMA_IDENTIFIER, numeric_1.EULER_GAMMA);
+    }
+    return constants.join(' ');
+}

package/output/core/functions/complex.d.ts

@@ -0,0 +1,90 @@
+import { Expression } from '../classes/expression/Expression';
+import type { ExpressionInput } from '../types';
+/**
+ * Retrieves the real part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+/**
+ * Retrieves the real part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+export declare function realPart(a: Expression): Expression;
+/**
+ * Retrieves the imaginary part of a complex number
+ *
+ * @param a
+ * @returns
+ */
+export declare function imagPart(a: Expression): Expression;
+/**
+ * Simplifies a*i^n with numeric powers and coefficients
+ *
+ * @param x
+ */
+export declare function simplifyImaginary(x: Expression): Expression;
+export declare function toPolarFormArray(x: Expression): Expression[];
+/**
+ * Calculates the polar from of a complex number
+ * //IMPROVE: Potential speed boost by just returning i.
+ *
+ * @param x
+ * @returns
+ */
+export declare function polarForm(x: Expression): Expression;
+/**
+ * Attempts to convert a polar form complex to rectangular form. If no exact identity
+ * is found, the decimal representation in rectangular form is returned.
+ *
+ * @param x
+ * @returns
+ */
+export declare function rectForm(x: ExpressionInput): Expression;
+/**
+ * Returns the argument of an expression
+ *
+ * @param x
+ * @returns
+ */
+export declare function arg(x: ExpressionInput): Expression;
+/**
+ * Returns the complex conjugate of an expression.
+ * For a complex number z = a + bi, the conjugate is a - bi.
+ * Distributes over sums, products, integer powers, and powers whose
+ * constant base is known not to lie on the principal logarithm's branch cut.
+ *
+ * @param expr - The expression to conjugate
+ * @returns The complex conjugate of the expression
+ *
+ * @example
+ * conjugate('3+2*i')    // 3-2*i
+ * conjugate('i')        // -i
+ * conjugate('a+b*i')    // a-b*i
+ * conjugate('(1+i)^i')  // (1-i)^(-i)
+ */
+export declare function conjugate(x: ExpressionInput): Expression;
+/**
+ * Returns the complex signum (csgn) of an expression, following the
+ * Maple/SymPy convention. Returns 1 if Re(z) > 0, -1 if Re(z) < 0,
+ * and sgn(Im(z)) if Re(z) = 0. Returns 0 for z = 0.
+ *
+ * For expressions containing free variables where the sign cannot be
+ * determined, returns an unevaluated symbolic csgn(z).
+ *
+ * Useful for branch cut decisions in sqrt, log, and power simplification.
+ *
+ * @param expr - The expression to evaluate the complex sign of
+ * @returns 1, -1, 0, or an unevaluated csgn expression
+ *
+ * @example
+ * csgn('3+2*i')   // 1
+ * csgn('-1+3*i')  // -1
+ * csgn('2*i')     // 1
+ * csgn('-5*i')    // -1
+ * csgn('0')       // 0
+ * csgn('x+2*i')   // csgn(x+2*i)
+ */
+export declare function csgn(x: ExpressionInput): Expression;