mathjslab/lib/src/ComplexInterface.d.ts

MathJSLab - An interpreter with language syntax like MATLAB®/Octave, ISBN 978-65-00-82338-7.

/**
 * Filename: `ComplexInterface.ts`
 * Description: Definitions for a complex number library based on a facade
 * architecture and method factories.
 * References:
 * * https://mathworld.wolfram.com/ComplexNumber.html
 */
import { Evaluator } from './Evaluator';
export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
export type RoundingName = 'up' | 'down' | 'ceil' | 'floor' | 'half_up' | 'half_down' | 'half_even' | 'half_ceil' | 'half_floor';
export type Modulo = Rounding | 9;
export type ModuloName = 'up' | 'down' | 'floor' | 'half_even' | 'euclid';
/**
 * `Complex` backend engine configuration.
 */
export interface ComplexConfig<ROUNDING = Rounding, MODULO = Modulo> {
    /**
     * The maximum number of significant digits of the result of an operation.
     * Values equal to or greater than 336 is used to produce correct rounding of
     * trigonometric, hyperbolic and exponential functions.
     */
    precision: number;
    /**
     * Number of significant digits to reduce precision before compare operations and
     * unparse.
     */
    precisionCompare: number;
    /**
     * The default rounding mode used when rounding the result of an operation to
     * precision significant digits.
     */
    rounding: ROUNDING;
    /**
     * The positive exponent value at and above which unparse returns exponential
     * notation.
     */
    toExpPos: number;
    /**
     * The negative exponent limit, i.e. the exponent value below which underflow
     * to zero occurs.
     */
    minE: number;
    /**
     * The positive exponent limit, i.e. the exponent value above which overflow
     * to Infinity occurs.
     */
    maxE: number;
    /**
     * The negative exponent value at and below which unparse returns exponential
     * notation.
     */
    toExpNeg: number;
    /**
     * The modulo mode used when calculating the modulus: a mod n.
     */
    modulo: MODULO;
    /**
     * The value that determines whether cryptographically-secure
     * pseudo-random number generation is used.
     */
    crypto: boolean;
}
/**
 * Key of ComplexInterfaceStatic type.
 */
export type ComplexConfigKey = keyof ComplexConfig;
export { ComplexConfigKeyTable } from './ComplexConfigKeyTable';
export type NumLike<REAL = number> = string | number | bigint | REAL;
export type NumType<TYPE = number> = TYPE;
export type NumParent<PARENT = unknown> = PARENT;
export interface ComplexInterface<REAL, TYPE = number, PARENT = unknown> {
    /**
     * Real, imaginary, `type` and `parent` properties.
     */
    re: REAL;
    im: REAL;
    type: TYPE;
    parent: PARENT;
    /**
     * Instance methods.
     */
    unparse(): string;
    copy(): ComplexInterface<REAL, TYPE, PARENT>;
    toLogical(): ComplexInterface<REAL, TYPE, PARENT>;
}
/**
 * Key of ComplexInterface type.
 */
export type ComplexInterfaceKey = keyof ComplexInterface<any, any>;
export { ComplexInterfaceKeyTable } from './ComplexInterfaceKeyTable';
export type OmitComplexInterfaceDynamic<REAL, TYPE, PARENT> = Omit<ComplexInterface<REAL, TYPE, PARENT>, ComplexInterfaceKey>;
export type ComplexLike<REAL, TYPE = number, PARENT = unknown> = {
    re?: NumLike<REAL>;
    im?: NumLike<REAL>;
    type?: NumType<TYPE>;
    parent?: NumParent<PARENT>;
};
export type TCompareOperationName = 'lt' | 'lte' | 'eq' | 'gt' | 'gte';
export type TMinMaxCompareOperationName = 'lt' | 'gte';
export type TMinMaxArrayCompareOperationName = 'lt' | 'gt';
export type ComplexHandlerType<REAL, COMPLEX extends ComplexInterface<REAL>> = COMPLEX;
export type IsInstanceOfComplexHandler = (value: unknown) => boolean;
export type SetComplexHandler = (config: Partial<ComplexConfig>) => void;
export type SetNumberTypeComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (value: COMPLEX) => void;
export type CreateComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>, TYPE = number, PARENT = unknown> = (re?: NumLike<REAL>, im?: NumLike<REAL>, type?: NumType<TYPE>, parent?: NumParent<PARENT>) => COMPLEX;
export type PartSetComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (value: COMPLEX, n: NumLike<REAL>) => void;
export type PartApplyComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (value: COMPLEX, func: (re: REAL) => REAL) => void;
export type PartApplyComplexHandlerTable<REAL> = Record<TApplyName, (n: REAL) => REAL>;
export type OneArgValueComplexHandler<REAL> = (value: REAL) => REAL;
export type FromComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (obj: Partial<COMPLEX>) => COMPLEX;
export type NoArgComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = () => COMPLEX;
export type OneArgComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX) => COMPLEX;
export type OneOptNumArgComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (significantDigits?: number) => COMPLEX;
export type OneArgNoReturnComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX) => void;
export type MapComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = OneArgComplexHandler<REAL, COMPLEX>;
export type TwoArgComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (x: COMPLEX, y: COMPLEX) => COMPLEX;
export type OneArgReturnBooleanComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX) => boolean;
export type OneArgReturnNumberComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX) => number;
export type TestNumLikeComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX, value: NumLike<REAL>) => boolean;
export type CompareValueComplexHandler<REAL> = (cmp: TCompareOperationName, left: REAL, right: REAL) => boolean;
export type CmpComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (cmp: TCompareOperationName, left: COMPLEX, right: COMPLEX) => COMPLEX;
export type ParseComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (value: string) => COMPLEX;
export type UnparseValueComplexHandler<REAL> = (value: REAL) => string;
export type UnparseComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>, PRECEDENCE = number> = (value: COMPLEX, parentPrecedence: PRECEDENCE) => string;
export type PrecedenceComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>, EVALUATOR, PRECEDENCE = number> = (value: COMPLEX, evaluator: EVALUATOR) => PRECEDENCE;
export type UnparseMathMLComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>, EVALUATOR, PRECEDENCE = number> = (value: COMPLEX, evaluator: EVALUATOR, parentPrecedence: PRECEDENCE) => string;
export type RandomComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (significantDigits?: number) => COMPLEX;
export type CompareComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (cmp: TCompareOperationName, left: COMPLEX, right: COMPLEX) => COMPLEX;
export type MinMaxArrayComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => COMPLEX;
export type MinMaxArrayWithIndexComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => [COMPLEX, number];
export type AbsoluteValueComplexHandler<REAL, COMPLEX extends ComplexInterface<REAL>> = (z: COMPLEX) => REAL;
/**
 * Binary operations name type.
 */
export type TBinaryOperationName = 'add' | 'sub' | 'mul' | 'rdiv' | 'ldiv' | 'power' | 'lt' | 'le' | 'eq' | 'ge' | 'gt' | 'ne' | 'and' | 'or' | 'xor' | 'mod' | 'rem' | 'minWise' | 'maxWise';
/**
 * Unary operations name type.
 */
export type TUnaryOperationLeftName = 'copy' | 'neg' | 'not';
export type TApplyName = 'fix' | 'ceil' | 'floor' | 'round' | 'sign' | 'trunc';
export interface RealInterfaceStatic<REAL> {
    create(x: REAL | number | string): REAL;
    add(a: REAL, b: REAL): REAL;
    sub(a: REAL, b: REAL): REAL;
    neg(x: REAL): REAL;
    mul(a: REAL, b: REAL): REAL;
    pow(a: REAL, b: REAL): REAL;
    div(a: REAL, b: REAL): REAL;
    mod(a: REAL, b: REAL): REAL;
    sqrt(x: REAL): REAL;
    trunc(x: REAL): REAL;
    ceil(x: REAL): REAL;
    floor(x: REAL): REAL;
    round(x: REAL): REAL;
    sign(x: REAL): REAL;
    exp(x: REAL): REAL;
    ln(x: REAL): REAL;
    abs(x: REAL): REAL;
    abs(x: REAL): REAL;
    sin(x: REAL): REAL;
    cos(x: REAL): REAL;
    atan2(x: REAL, y: REAL): REAL;
    sinh(x: REAL): REAL;
    cosh(x: REAL): REAL;
    MINUSONE: REAL;
    ZERO: REAL;
    TWO: REAL;
    PI: REAL;
    PI_DEG: REAL;
    INF: REAL;
    unparse(value: REAL): string;
    isNeg(x: REAL): boolean;
    isZero(x: REAL): boolean;
    isNaN(x: REAL): boolean;
    isFinite(x: REAL): boolean;
}
export interface ComplexInterfaceStatic<REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo> {
    /**
     * COMPLEX most restricted number class.
     */
    readonly LOGICAL: TYPE;
    readonly REAL: TYPE;
    readonly COMPLEX: TYPE;
    /**
     * COMPLEX engine default settings.
     */
    readonly defaultSettings: ComplexConfig<ROUNDING, MODULO>;
    /**
     * COMPLEX engine current settings.
     */
    readonly settings: ComplexConfig<ROUNDING, MODULO>;
    /**
     * COMPLEX constructor
     * @param re Real part (optional).
     * @param im Imaginary part (optional).
     * @param type Class 'complex' | 'logical' (optional).
     * @param parent
     */
    new (re?: NumLike<REAL>, im?: NumLike<REAL>, type?: NumType<TYPE>, parent?: NumParent<PARENT>): COMPLEX;
    /**
     * Test if `value` is instance of COMPLEX.
     * @param value Value to test.
     * @returns `true` if value is instance of COMPLEX. `false` otherwise.
     */
    readonly isInstanceOf: (value: unknown) => boolean;
    /**
     * `COMPLEX` engine setup.
     * @param config `Object` with `COMPLEX` engine configurations
     * parameters:
     * - `precision`: Number of significant digits to reduce precision before
     * compare operations and unparse.
     * - `rounding`: The default rounding mode used when rounding the result
     * of an operation to precision significant digits.
     * - `toExpPos`: The positive exponent value at and above which unparse
     * returns exponential notation.
     * - `toExpNeg`: The negative exponent limit, i.e. the exponent value
     * below which underflow to zero occurs.
     * - `minE`: The positive exponent limit, i.e. the exponent value above
     * which overflow to Infinity occurs.
     * - `maxE`: The negative exponent value at and below which unparse
     * returns exponential notation.
     * - `modulo`: The modulo mode used when calculating the modulus: a mod n.
     * - `crypto`: The value that determines whether cryptographically-secure
     * pseudo-random number generation is used.
     */
    readonly set: (config: Partial<ComplexConfig<ROUNDING, MODULO>>) => void;
    /**
     * Set number type (`ctor.LOGICAL`, `ctor.REAL` or `ctor.COMPLEX`).
     * @param value number type.
     */
    readonly setNumberType: (value: COMPLEX) => void;
    readonly create: (re?: NumLike<REAL>, im?: NumLike<REAL>, type?: NumType<TYPE>, parent?: NumParent<PARENT>) => COMPLEX;
    /**
     * Sets the real part of the `COMPLEX`.
     * @param value
     * @param re
     */
    readonly realSet: (value: COMPLEX, re: NumLike<REAL>) => void;
    /**
     * Sets the imaginary part of the `COMPLEX`.
     * @param value
     * @param re
     */
    readonly imagSet: (value: COMPLEX, im: NumLike<REAL>) => void;
    /**
     * Sets the real part of the `COMPLEX` by applying a function to the
     * original value.
     * @param value
     * @param im
     */
    readonly realApply: (value: COMPLEX, func: (re: REAL) => REAL) => void;
    /**
     * Sets the imaginary part of the `COMPLEX` by applying a function to
     * the original value.
     * @param value
     * @param im
     */
    readonly imagApply: (value: COMPLEX, func: (im: REAL) => REAL) => void;
    /**
     * Creates a `COMPLEX` from another.
     * @param obj Original `COMPLEX`.
     * @returns A new `COMPLEX`.
     */
    readonly from: (obj: COMPLEX) => COMPLEX;
    /**
     * Real part of complex number.
     * @param z value.
     * @returns Real part of z
     */
    readonly real: (z: COMPLEX) => COMPLEX;
    /**
     * Imaginary part of complex number.
     * @param z value.
     * @returns Imaginary part of z
     */
    readonly imag: (z: COMPLEX) => COMPLEX;
    /**
     * Tests whether the real part is an integer.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is an integer. `false` otherwise.
     */
    readonly realIsInteger: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is an integer.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is an integer. `false` otherwise.
     */
    readonly imagIsInteger: (z: COMPLEX) => boolean;
    /**
     * Tests whether the real part is finite.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is finite. `false` otherwise.
     */
    readonly realIsFinite: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is finite.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is finite. `false` otherwise.
     */
    readonly imagIsFinite: (z: COMPLEX) => boolean;
    /**
     * Tests whether the real part is `NaN`.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is `NaN`. `false` otherwise.
     */
    readonly realIsNaN: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is `NaN`.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is `NaN`. `false` otherwise.
     */
    readonly imagIsNaN: (z: COMPLEX) => boolean;
    /**
     * Tests whether the real part is negative.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is negative. `false` otherwise.
     */
    readonly realIsNegative: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is negative.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is negative. `false` otherwise.
     */
    readonly imagIsNegative: (z: COMPLEX) => boolean;
    /**
     * Tests whether the real part is zero.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is zero. `false` otherwise.
     */
    readonly realIsZero: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is zero.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is zero. `false` otherwise.
     */
    readonly imagIsZero: (z: COMPLEX) => boolean;
    /**
     * Tests whether the real part is positive.
     * @param z `COMPLEX` to test.
     * @returns `true` if the real part is positive. `false` otherwise.
     */
    readonly realIsPositive: (z: COMPLEX) => boolean;
    /**
     * Tests whether the imaginary part is positive.
     * @param z `COMPLEX` to test.
     * @returns `true` if the imaginary part is positive. `false` otherwise.
     */
    readonly imagIsPositive: (z: COMPLEX) => boolean;
    /**
     * Converts the real part to type `number`.
     * @param z `COMPLEX` value to convert real part.
     * @returns Real part of `COMPLEX` value coverted to `number`.
     */
    readonly realToNumber: (z: COMPLEX) => number;
    /**
     * Converts the imaginary part to type `number`.
     * @param z `COMPLEX` value to convert imaginary part.
     * @returns Imaginary part of `COMPLEX` value coverted to `number`.
     */
    readonly imagToNumber: (z: COMPLEX) => number;
    /**
     * Tests whether the real part is less than a value.
     * @param z `COMPLEX` to test real part.
     * @param value `REAL` value to compare with real part.
     * @returns `true` if real part is less than value. `false` otherwise.
     */
    readonly realLessThan: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the imaginary part is less than a value.
     * @param z `COMPLEX` to test imaginary part.
     * @param value `REAL` value to compare with imaginary part.
     * @returns `true` if imaginary part is less than value. `false` otherwise.
     */
    readonly imagLessThan: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the real part is less than or equals a value.
     * @param z `COMPLEX` to test real part.
     * @param value `REAL` value to compare with real part.
     * @returns `true` if real part is less than or equals value. `false` otherwise.
     */
    readonly realLessThanOrEqualTo: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the imaginary part is less than or equals a value.
     * @param z `COMPLEX` to test imaginary part.
     * @param value `REAL` value to compare with imaginary part.
     * @returns `true` if imaginary part is less than or equals value. `false` otherwise.
     */
    readonly imagLessThanOrEqualTo: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the real part is equals a value.
     * @param z `COMPLEX` to test real part.
     * @param value `REAL` value to compare with real part.
     * @returns `true` if real part is equals value. `false` otherwise.
     */
    readonly realEquals: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the imaginary part is equals a value.
     * @param z `COMPLEX` to test imaginary part.
     * @param value `REAL` value to compare with imaginary part.
     * @returns `true` if imaginary part is equals value. `false` otherwise.
     */
    readonly imagEquals: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the real part is greater than or equals a value.
     * @param z `COMPLEX` to test real part.
     * @param value `REAL` value to compare with real part.
     * @returns `true` if real part is greater than or equals value. `false` otherwise.
     */
    readonly realGreaterThanOrEqualTo: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the imaginary part is greater than or equals a value.
     * @param z `COMPLEX` to test imaginary part.
     * @param value `REAL` value to compare with imaginary part.
     * @returns `true` if imaginary part is greater than or equals value. `false` otherwise.
     */
    readonly imagGreaterThanOrEqualTo: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the real part is greater than a value.
     * @param z `ComplexNumber` to test real part.
     * @param value `number` value to compare with real part.
     * @returns `true` if real part is greater than value. `false` otherwise.
     */
    readonly realGreaterThan: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    /**
     * Tests whether the imaginary part is greater than a value.
     * @param z `COMPLEX` to test imaginary part.
     * @param value `REAL` value to compare with imaginary part.
     * @returns `true` if imaginary part is greater than value. `false` otherwise.
     */
    readonly imagGreaterThan: (z: COMPLEX, value: NumLike<REAL>) => boolean;
    readonly parse: (value: string) => COMPLEX;
    readonly unparseValue: (value: REAL) => string;
    readonly unparse: (value: COMPLEX, parentPrecedence: PRECEDENCE) => string;
    readonly unparseMathMLValue: (value: REAL) => string;
    readonly precedence: (value: COMPLEX, evaluator: Evaluator) => PRECEDENCE;
    readonly unparseMathML: (value: COMPLEX, evaluator: Evaluator, parentPrecedence: PRECEDENCE) => string;
    readonly copy: (value: COMPLEX) => COMPLEX;
    /**
     * Reduce precision of real or imaginary part.
     * @param value Full precision value.
     * @returns Reduced precision value.
     */
    readonly toMaxPrecisionValue: (value: REAL) => REAL;
    readonly toMaxPrecision: (value: COMPLEX) => COMPLEX;
    /**
     * Get the minimal diference of two consecutive numbers for real or
     * imaginary part, the floating-point relative accuracy.
     * @returns Minimal diference of two consecutive numbers.
     */
    readonly epsilonValue: () => REAL;
    readonly epsilon: () => COMPLEX;
    /**
     * Returns a new `COMPLEX` with a pseudo-random value equal to or
     * greater than 0 and less than 1. The return value will have
     * significantDigits decimal places (or less if trailing zeros are
     * produced). If significantDigits is omitted then the number of decimal
     * places will default to the current `precision` setting.
     * @param significantDigits
     * @returns Random number.
     */
    readonly random: (significantDigits?: number) => COMPLEX;
    readonly eq: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly ne: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly compareValue: (cmp: TCompareOperationName, left: REAL, right: REAL) => boolean;
    readonly cmp: (cmp: TCompareOperationName, left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly minMaxArrayReal: (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => COMPLEX;
    readonly minMaxArrayRealWithIndex: (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => [COMPLEX, number];
    readonly minMaxArrayComplex: (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => COMPLEX;
    readonly minMaxArrayComplexWithIndex: (cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => [COMPLEX, number];
    readonly min: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly minWise: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly max: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly maxWise: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly lt: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly le: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly gt: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly ge: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    /**
     * `COMPLEX` logical false.
     * @returns `false` as `COMPLEX`.
     */
    readonly false: () => COMPLEX;
    /**
     * `COMPLEX` logical true.
     * @returns `true` as `COMPLEX`.
     */
    readonly true: () => COMPLEX;
    readonly logical: (value: COMPLEX) => COMPLEX;
    readonly toLogical: (value: COMPLEX) => COMPLEX;
    readonly and: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly or: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly xor: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly not: (right: COMPLEX) => COMPLEX;
    /**
     * 0
     * @returns 0 as `COMPLEX`.
     */
    readonly zero: () => COMPLEX;
    /**
     * 1
     * @returns 1 as `COMPLEX`.
     */
    readonly one: () => COMPLEX;
    /**
     * 1/2
     * @returns 1/2 as `COMPLEX`.
     */
    readonly onediv2: () => COMPLEX;
    /**
     * -1/2
     * @returns -1/2 as `COMPLEX`.
     */
    readonly minusonediv2: () => COMPLEX;
    /**
     * -1
     * @returns -1 as `COMPLEX`.
     */
    readonly minusone: () => COMPLEX;
    /**
     * pi
     * @returns pi as `COMPLEX`.
     */
    readonly pi: () => COMPLEX;
    /**
     * pi/2
     * @returns pi/2 as `COMPLEX`.
     */
    readonly pidiv2: () => COMPLEX;
    /**
     * i
     * @returns i as `COMPLEX`.
     */
    readonly onei: () => COMPLEX;
    /**
     * i/2
     * @returns i/2 as `COMPLEX`.
     */
    readonly onediv2i: () => COMPLEX;
    /**
     * -i/2
     * @returns -i/2 as `COMPLEX`.
     */
    readonly minusonediv2i: () => COMPLEX;
    /**
     * -i
     * @returns -i as `COMPLEX`.
     */
    readonly minusonei: () => COMPLEX;
    /**
     * 2
     * @returns 2 as `COMPLEX`.
     */
    readonly two: () => COMPLEX;
    /**
     * sqrt(2*pi)
     * @returns sqrt(2*pi) as `COMPLEX`.
     */
    readonly sqrt2pi: () => COMPLEX;
    /**
     * e (Napier number).
     * @returns e as `COMPLEX`.
     */
    readonly e: () => COMPLEX;
    /**
     * NaN
     * @returns NaN as `COMPLEX`.
     */
    readonly NaN_0: () => COMPLEX;
    /**
     * Inf
     * @returns Inf as `COMPLEX`.
     */
    readonly inf_0: () => COMPLEX;
    /**
     * Addition of COMPLEX numbers.
     * @param left Value.
     * @param right Value.
     * @returns left + right
     */
    readonly add: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    /**
     * Subtraction of `COMPLEX` numbers.
     * @param left Value
     * @param right Value
     * @returns left - right
     */
    readonly sub: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    /**
     * Negates the `COMPLEX` number.
     * @param z Value.
     * @returns -z
     */
    readonly neg: (z: COMPLEX) => COMPLEX;
    readonly mul: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly rdiv: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    /**
     * Left division. For `COMPLEX` the left division is the same of right division.
     * @param left Dividend.
     * @param right Divisor.
     * @returns left \ right.
     */
    readonly ldiv: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly inv: (x: COMPLEX) => COMPLEX;
    readonly power: (left: COMPLEX, right: COMPLEX) => COMPLEX;
    readonly root: (x: COMPLEX, n: COMPLEX) => COMPLEX;
    readonly absValue: (z: COMPLEX) => REAL;
    readonly abs: (z: COMPLEX) => COMPLEX;
    readonly hypot: (x: COMPLEX, y: COMPLEX) => COMPLEX;
    readonly arg: (z: COMPLEX) => COMPLEX;
    readonly conj: (z: COMPLEX) => COMPLEX;
    readonly mod: (x: COMPLEX, y: COMPLEX) => COMPLEX;
    readonly rem: (x: COMPLEX, y: COMPLEX) => COMPLEX;
    readonly fix: (z: COMPLEX) => COMPLEX;
    readonly ceil: (z: COMPLEX) => COMPLEX;
    readonly floor: (z: COMPLEX) => COMPLEX;
    readonly round: (z: COMPLEX) => COMPLEX;
    readonly sign: (z: COMPLEX) => COMPLEX;
    readonly sqrt: (z: COMPLEX) => COMPLEX;
    readonly exp: (z: COMPLEX) => COMPLEX;
    readonly log: (z: COMPLEX) => COMPLEX;
    readonly logb: (b: COMPLEX, l: COMPLEX) => COMPLEX;
    readonly log2: (z: COMPLEX) => COMPLEX;
    readonly log10: (z: COMPLEX) => COMPLEX;
    readonly deg2rad: (z: COMPLEX) => COMPLEX;
    readonly rad2deg: (z: COMPLEX) => COMPLEX;
    readonly sin: (z: COMPLEX) => COMPLEX;
    readonly sind: (z: COMPLEX) => COMPLEX;
    readonly cos: (z: COMPLEX) => COMPLEX;
    readonly cosd: (z: COMPLEX) => COMPLEX;
    readonly tan: (z: COMPLEX) => COMPLEX;
    readonly tand: (z: COMPLEX) => COMPLEX;
    readonly csc: (z: COMPLEX) => COMPLEX;
    readonly cscd: (z: COMPLEX) => COMPLEX;
    readonly sec: (z: COMPLEX) => COMPLEX;
    readonly secd: (z: COMPLEX) => COMPLEX;
    readonly cot: (z: COMPLEX) => COMPLEX;
    readonly cotd: (z: COMPLEX) => COMPLEX;
    readonly asin: (z: COMPLEX) => COMPLEX;
    readonly asind: (z: COMPLEX) => COMPLEX;
    readonly acos: (z: COMPLEX) => COMPLEX;
    readonly acosd: (z: COMPLEX) => COMPLEX;
    readonly atan: (z: COMPLEX) => COMPLEX;
    readonly atand: (z: COMPLEX) => COMPLEX;
    readonly acsc: (z: COMPLEX) => COMPLEX;
    readonly acscd: (z: COMPLEX) => COMPLEX;
    readonly asec: (z: COMPLEX) => COMPLEX;
    readonly asecd: (z: COMPLEX) => COMPLEX;
    readonly acot: (z: COMPLEX) => COMPLEX;
    readonly acotd: (z: COMPLEX) => COMPLEX;
    readonly sinh: (z: COMPLEX) => COMPLEX;
    readonly cosh: (z: COMPLEX) => COMPLEX;
    readonly tanh: (z: COMPLEX) => COMPLEX;
    readonly csch: (z: COMPLEX) => COMPLEX;
    readonly sech: (z: COMPLEX) => COMPLEX;
    readonly coth: (z: COMPLEX) => COMPLEX;
    readonly asinh: (z: COMPLEX) => COMPLEX;
    readonly acosh: (z: COMPLEX) => COMPLEX;
    readonly atanh: (z: COMPLEX) => COMPLEX;
    readonly acsch: (z: COMPLEX) => COMPLEX;
    readonly asech: (z: COMPLEX) => COMPLEX;
    readonly acoth: (z: COMPLEX) => COMPLEX;
    readonly gamma: (z: COMPLEX) => COMPLEX;
    readonly factorial: (x: COMPLEX) => COMPLEX;
    applyFunction: PartApplyComplexHandlerTable<REAL>;
    mapFunction: Record<string, (z: COMPLEX) => COMPLEX>;
    twoArgFunction: Record<string, (x: COMPLEX, y: COMPLEX) => COMPLEX>;
}
/**
 * Key of ComplexInterfaceStatic type.
 */
export type ComplexInterfaceStaticKey = keyof ComplexInterfaceStatic<any, any>;
export { ComplexInterfaceStaticKeyTable } from './ComplexInterfaceStaticKeyTable';
export declare const roundingMode: Record<string, Rounding | Modulo>;
export declare const roundingName: RoundingName[];
export declare const moduloName: ModuloName[];
/**
 * Most restricted number class.
 */
export declare const numberClass: Record<string, number>;
/**
 * Factory for `ctor.setNumberType` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.setNumberType` COMPLEX method.
 */
export declare const setNumberTypeFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX) => void);
/**
 * Factory for `ctor.create` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.create` COMPLEX method.
 */
export declare const createFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((re?: NumLike<REAL>, im?: NumLike<REAL>, type?: NumType<TYPE>, parent?: NumParent<PARENT>) => COMPLEX);
/**
 * Factory for `ctor.parse` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.parse` COMPLEX method.
 */
export declare const parseFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: string) => COMPLEX);
/**
 * Factory for `ctor.unparseValue` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.unparseValue` method.
 */
export declare const unparseValueFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: REAL) => string);
/**
 * Factory for `ctor.unparse` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.unparse` COMPLEX method.
 */
export declare const unparseFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX, parentPrecedence?: number) => string);
/**
 * Factory for `ctor.unparseMathMLValue` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.unparseMathMLValue` method.
 */
export declare const unparseMathMLValueFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: REAL) => string);
/**
 * Factory for `ctor.precedence` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.precedence` COMPLEX method.
 */
export declare const precedenceFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX, evaluator: Evaluator) => number);
/**
 * Factory for `ctor.unparseMathML` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.unparseMathML` COMPLEX method.
 */
export declare const unparseMathMLFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX, evaluator: Evaluator, parentPrecedence?: number) => string);
/**
 * Factory for `ctor.toMaxPrecision` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.toMaxPrecision` COMPLEX method.
 */
export declare const toMaxPrecisionFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.copy` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.copy` COMPLEX method.
 */
export declare const copyFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.epsilon` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.epsilon` COMPLEX method.
 */
export declare const epsilonFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => (() => COMPLEX);
/**
 * Factory for `ctor.eq` and `ctor.ne` methods.
 * @param ctor COMPLEX instance constructor.
 * @param test Logic value for true test result (`true` for `ctor.eq` and `false` for `ctor.ne`)
 * @returns `ctor.eq` or `ctor.ne` COMPLEX method.
 */
export declare const equalsFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>, test?: boolean) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.cmp` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.cmp` COMPLEX method.
 */
export declare const cmpFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((cmp: TCompareOperationName, left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.minMaxArrayReal` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.minMaxArrayReal` COMPLEX method.
 */
export declare const minMaxArrayRealFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => COMPLEX);
/**
 * Factory for `ctor.minMaxArrayRealWithIndex` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.minMaxArrayRealWithIndex` COMPLEX method.
 */
export declare const minMaxArrayRealWithIndexFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => [COMPLEX, number]);
/**
 * Factory for `ctor.minMaxArrayComplex` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.minMaxArrayComplex` COMPLEX method.
 */
export declare const minMaxArrayComplexFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => COMPLEX);
/**
 * Factory for `ctor.minMaxArrayComplexWithIndex` method.
 * @param ctor COMPLEX instance constructor.
 * @returns `ctor.minMaxArrayComplexWithIndex` COMPLEX method.
 */
export declare const minMaxArrayComplexWithIndexFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((cmp: TMinMaxArrayCompareOperationName, ...args: COMPLEX[]) => [COMPLEX, number]);
/**
 * Factory for `ctor.min` and `ctor.max` methods.
 * @param ctor COMPLEX instance constructor.
 * @param cmp `'lt'` for `ctor.min` result or `'gte'` for `ctor.max` result.
 * @returns `ctor.min` or `ctor.max` COMPLEX method.
 */
export declare const minMaxFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>, cmp: TMinMaxCompareOperationName) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.minWise` and `ctor.maxWise` methods.
 * @param ctor COMPLEX instance constructor.
 * @param cmp `'lt'` for `ctor.minWise` result or `'gte'` for `ctor.maxWise` result.
 * @returns `ctor.minWise` or `ctor.maxWise` COMPLEX method.
 */
export declare const minMaxWiseFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>, cmp: TMinMaxCompareOperationName) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for comparison methods (`ctor.lt`, `ctor.le`, `ctor.gt` and `ctor.ge`).
 * @param ctor COMPLEX instance constructor.
 * @param cmp Comparison descriptor.
 * @returns `ctor.lt`, `ctor.le`, `ctor.gt` and `ctor.ge` COMPLEX methods.
 */
export declare const comparisonFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>, cmp: TCompareOperationName) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.logical` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.logical` method.
 */
export declare const logicalFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((value: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.and` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.and` method.
 */
export declare const andFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.or` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.or` method.
 */
export declare const orFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.xor` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.xor` method.
 */
export declare const xorFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.not` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.not` method.
 */
export declare const notFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((right: COMPLEX) => COMPLEX);
/**
 * Factory for literal complex values.
 * @param ctor Complex instance constructor.
 * @param real Real part value.
 * @param imag Imaginary part value.
 * @param type Number type value.
 * @returns Literal value COMPLEX method `(): COMPLEX => new ctor(real, imag, type);`.
 */
export declare const literalFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>, real?: NumLike<REAL>, imag?: NumLike<REAL>, type?: NumType<TYPE>) => (() => COMPLEX);
/**
 * Factory for `ctor.mul` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.mul` method.
 */
export declare const mulFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.rdiv` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.rdiv` method.
 */
export declare const rdivFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.inv` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.inv` method.
 */
export declare const invFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.power` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.power` method.
 */
export declare const powerFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((left: COMPLEX, right: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.root` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.root` method.
 */
export declare const rootFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX, n: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.absValue` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.absValue` method.
 */
export declare const absValueFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown) => ((z: COMPLEX) => REAL);
/**
 * Factory for `ctor.abs` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.abs` method.
 */
export declare const absFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.hypot` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.root` method.
 */
export declare const hypotFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((x: COMPLEX, y: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.arg` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.arg` method.
 */
export declare const argFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.conj` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.conj` method.
 */
export declare const conjFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.mod` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.mod` method.
 */
export declare const modFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((x: COMPLEX, y: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.rem` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.rem` method.
 */
export declare const remFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((x: COMPLEX, y: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.fix` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.fix` method.
 */
export declare const fixFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.ceil` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.ceil` method.
 */
export declare const ceilFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.floor` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.floor` method.
 */
export declare const floorFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.round` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.round` method.
 */
export declare const roundFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.sign` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.sign` method.
 */
export declare const signFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.sqrt` method.
 * @param ctor Complex instance constructor.
 * @returns `ctor.sqrt` method.
 */
export declare const sqrtFactory: <REAL, COMPLEX extends ComplexInterface<REAL, TYPE, PARENT>, TYPE = number, PARENT = unknown, PRECEDENCE = number, ROUNDING = Rounding, MODULO = Modulo>(rctor: RealInterfaceStatic<REAL> | unknown, ctor: ComplexInterfaceStatic<REAL, COMPLEX, TYPE, PARENT, PRECEDENCE, ROUNDING, MODULO>) => ((z: COMPLEX) => COMPLEX);
/**
 * Factory for `ctor.exp` method.
 * @param ctor Complex instance constructor.
 * @retu