import { ComplexDecimal, TBinaryOperationName, TUnaryOperationLeftName } from './complex-decimal';
import { Evaluator, TNameTable } from './evaluator';
/**
 * # MultiArray
 *
 * A multimensional array library.
 */
export declare class MultiArray {
    /**
     * Dimensions property ([lines, columns, pages, blocks, ...]).
     */
    dimension: number[];
    /**
     * Dimensions excluding columns getter ([lines, pages, blocks, ...]).
     */
    get dimensionR(): number[];
    /**
     * Array property.
     */
    array: ComplexDecimal[][];
    /**
     * Type property.
     */
    type: number;
    /**
     * Parent node property.
     */
    parent: any;
    /**
     * MultiArray constructor.
     * @param shape Array<number> of dimensions ([rows, columns, pages, blocks, ...]).
     * @param fill Data to fill MultiArray. The same object will be put in all elements of MultiArray.
     */
    constructor(shape?: number[], fill?: any);
    /**
     * Check if object is a MultiArray.
     * @param obj Any object.
     * @returns true if object is a MultiArray. false otherwise.
     */
    static isThis(obj: any): boolean;
    /**
     * Check if object is a MultiArray and it is a row vector. To be used
     * only in Evaluator to test multiple assignment. The restrictions
     * imposed by parser can restrict the check only to `obj.dimension[0] === 1`.
     * @param obj
     * @returns true if object is a row vector. false otherwise.
     */
    static isRowVector(obj: any): boolean;
    /**
     * Set type property in place with maximum value of array items type.
     * @param M MultiArray to set type property.
     */
    static setType(M: MultiArray): void;
    /**
     * Test if two array are equals.
     * @param left Array<boolean | number | string>.
     * @param right Array<boolean | number | string>.
     * @returns true if two arrays are equals. false otherwise.
     */
    static arrayEquals(a: (boolean | number | string)[], b: (boolean | number | string)[]): boolean;
    /**
     * Returns a one-based range array ([1, 2, ..., length]).
     * @param length Length or last value of range array.
     * @returns Range array.
     */
    static rangeArray(length: number): number[];
    /**
     * Converts linear index to subscript.
     * @param dimension Dimensions of multidimensional array ([line, column, page, block, ...]).
     * @param index Zero-based linear index.
     * @returns One-based subscript ([line, column, page, block, ...]).
     */
    static linearIndexToSubscript(dimension: number[], index: number): number[];
    /**
     * Converts subscript to linear index.
     * @param dimension Dimensions of multidimensional array ([line, column, page, block, ...]).
     * @param subscript One-based subscript ([line, column, page, block, ...]).
     * @returns Zero-based linear index.
     */
    static subscriptToLinearIndex(dimension: number[], subscript: number[]): number;
    /**
     * Converts linear index to Multiarray.array subscript.
     * @param row Row dimension.
     * @param column Column dimension.
     * @param index Zero-based linear index.
     * @returns Multiarray.array subscript ([row, column]).
     */
    static linearIndexToMultiArrayRowColumn(row: number, column: number, index: number): [number, number];
    /**
     * Converts MultiArray subscript to Multiarray.array subscript.
     * @param dimension MultiArray dimension.
     * @param subscript Subscript.
     * @returns Multiarray.array subscript ([row, column]).
     */
    static subscriptToMultiArrayRowColumn(dimension: number[], subscript: number[]): [number, number];
    /**
     * Base method of the ind2sub function. Returns dimension.length + 1
     * dimensions. If the index exceeds the dimensions, the last dimension
     * will contain the multiplier of the other dimensions. Otherwise it will
     * be 1.
     * @param dimension Array of dimensions.
     * @param index One-base linear index.
     * @returns One-based subscript ([line, column, page, block, ...]).
     */
    static ind2subNumber(dimension: number[], index: number): number[];
    /**
     * Returns the number of elements in M.
     * @param M Multidimensional array.
     * @returns Number of elements in M.
     */
    static linearLength(M: MultiArray): number;
    /**
     * Get dimension at index d of MultiArray M
     * @param M Multiarray.
     * @param d Zero-based dimension index.
     * @returns Dimension d.
     */
    static getDimension(M: MultiArray, d: number): number;
    /**
     * Remove singleton tail of dimension array in place.
     * @param dimension Dimension array.
     */
    static removeSingletonTail(dimension: number[]): void;
    /**
     * Append singleton tail of dimension array in place.
     * @param dimension Dimension array.
     * @param length Resulting length of dimension array.
     */
    static appendSingletonTail(dimension: number[], length: number): void;
    /**
     * Find first non-single dimension.
     * @param M MultiArray.
     * @returns First non-single dimension of `M`.
     */
    static firstNonSingleDimension(M: MultiArray): number;
    /**
     * Creates a MultiArray object from the first row of elements (for
     * parsing purposes).
     * @param row Array of objects.
     * @returns MultiArray with `row` parameter as first line.
     */
    static firstRow(row: any[]): MultiArray;
    /**
     * Append a row of elements to a MultiArray object (for parsing
     * purposes).
     * @param M MultiArray.
     * @param row Array of objects to append as row of MultiArray.
     * @returns MultiArray with row appended.
     */
    static appendRow(M: MultiArray, row: any[]): MultiArray;
    /**
     * Swap two rows of a MultiArray in place.
     * @param M
     * @param m
     * @param n
     */
    static swapRows(M: MultiArray, m: number, n: number): void;
    /**
     * Unparse MultiArray.
     * @param M MultiArray object.
     * @returns String of unparsed MultiArray.
     */
    static unparse(M: MultiArray): string;
    /**
     * Unparse MultiArray as MathML language.
     * @param M MultiArray object.
     * @returns String of unparsed MultiArray in MathML language.
     */
    static unparseMathML(M: MultiArray): string;
    /**
     * Evaluate array. Calls `global.EvaluatorPointer.Evaluator` function for each element of page (matrix row-ordered)
     * @param array Matrix.
     * @param local `local` Evaluator parameter.
     * @param fname `fname` Evaluator parameter.
     * @param parent Parent node of items in page.
     * @returns Evaluated matrix.
     */
    private static evaluatePage;
    /**
     * Evaluate MultiArray object. Calls `MultiArray.evaluatePage` method for each page of
     * multidimensional array.
     * @param M MultiArray object.
     * @param local Local context (function evaluation).
     * @param fname Function name (context).
     * @returns Evaluated MultiArray object.
     */
    static evaluate(M: MultiArray, local?: boolean, fname?: string): MultiArray;
    /**
     * Linearize MultiArray in an array of any using column-major
     * order.
     * @param M Multidimensional array.
     * @returns `any[]` of multidimensional array `M` linearized.
     */
    static linearize(M: MultiArray | any): any[];
    /**
     * Returns a null array (0x0 matrix).
     * @returns Null array (0x0 matrix).
     */
    static array_0x0(): MultiArray;
    /**
     * Convert a scalar value to 1x1 MultiArray.
     * @param value MultiArray or scalar.
     * @returns MultiArray 1x1 if value is scalar.
     */
    static scalarToMultiArray(value: MultiArray | any): MultiArray;
    /**
     * If `value` parameter is a MultiArray of size 1x1 then returns as scalar.
     * @param value MultiArray or scalar.
     * @returns Scalar value if `value` parameter has all dimensions as singular.
     */
    static MultiArrayToScalar(value: MultiArray | any): MultiArray | any;
    /**
     * If `value` parameter is a MultiArray returns it's first element.
     * Otherwise returns `value` parameter.
     * @param value
     * @returns
     */
    static firstElement(value: MultiArray | any): any;
    /**
     * Converts a ComplexDecimal array or a single line MultiArray to an array
     * or number.
     * @param M
     * @returns
     */
    static oneRowToDim(M: ComplexDecimal[] | MultiArray): number[];
    /**
     * Create MultiArray with all elements equals `fill` parameter.
     * @param fill Value to fill MultiArray.
     * @param dimension Dimensions of created MultiArray.
     * @returns MultiArray filled with `fill` parameter.
     */
    static newFilled(fill: any, ...dimension: any): MultiArray | ComplexDecimal;
    /**
     * Create MultiArray with all elements filled with `fillFunction` result.
     * The parameter passed to `fillFunction` is a linear index of element.
     * @param fillFunction Function to be called and the result fills element of MultiArray created.
     * @param dimension Dimensions of created MultiArray.
     * @returns MultiArray filled with `fillFunction` results for each element.
     */
    static newFilledEach(fillFunction: (index: number) => any, ...dimension: any): MultiArray | ComplexDecimal;
    /**
     * Copy of MultiArray.
     * @param M MultiArray.
     * @returns Copy of MultiArray.
     */
    static copy(M: MultiArray): MultiArray;
    /**
     * Convert MultiArray to logical value. It's true if all elements is
     * non-null. Otherwise is false.
     * @param M
     * @returns
     */
    static toLogical(M: MultiArray): ComplexDecimal;
    /**
     * Calls a defined callback function on each element of an MultiArray,
     * and returns an MultiArray that contains the results.
     * @param M Matrix.
     * @param f Function mapping.
     * @returns
     */
    static map(M: MultiArray, f: Function): MultiArray;
    /**
     * Expand Multidimensional array dimensions if dimensions in `dim` is greater than dimensions of `M`.
     * If a dimension of `M` is greater than corresponding dimension in `dim` it's unchanged.
     * The array is filled with zeros and is expanded in place.
     * @param M Multidimensional array.
     * @param dim New dimensions.
     */
    static expand(M: MultiArray, dim: number[]): void;
    /**
     * Expand range.
     * @param startNode Start of range.
     * @param stopNode Stop of range.
     * @param strideNode Optional stride value.
     * @returns MultiArray of range expanded.
     */
    static expandRange(startNode: ComplexDecimal, stopNode: ComplexDecimal, strideNode?: ComplexDecimal | null): MultiArray;
    /**
     * Check if subscript is a integer number, convert ComplexDecimal to
     * number.
     * @param k Index as ComplexDecimal.
     * @param input Optional id reference of object.
     * @returns k as number, if real part is integer greater than 1 and imaginary part is 0.
     */
    static testIndex(k: ComplexDecimal, input?: string): number;
    /**
     * Check if subscript is a integer number, convert ComplexDecimal to
     * number, then check if it's less than bound.
     * @param k Index as ComplexDecimal.
     * @param bound Maximum acceptable value for the index
     * @param dim Dimensions (to generate error message)
     * @param input Optional string to generate error message.
     * @returns Index as number.
     */
    static testIndexBound(k: ComplexDecimal, bound: number, dim: number[], input?: string): number;
    /**
     * Converts subscript to linear index. Performs checks and throws
     * comprehensive errors if dimension bounds are exceeded.
     * @param dimension Dimension of multidimensional array ([line, column, page, block, ...]) as number[].
     * @param subscript Subscript ([line, column, page, block, ...]) as a ComplexDecimal[].
     * @param input Input string to generate error messages (the id of array).
     * @returns linear index.
     */
    static parseSubscript(dimension: number[], subscript: ComplexDecimal[], input?: string, that?: Evaluator): number;
    /**
     * Binary operation 'scalar `operation` array'.
     * @param op Binary operation name.
     * @param left Left operand (scalar).
     * @param right Right operand (array).
     * @returns Result of operation.
     */
    static scalarOpMultiArray(op: TBinaryOperationName, left: ComplexDecimal, right: MultiArray): MultiArray;
    /**
     * Binary operation 'array `operation` scalar'.
     * @param op Binary operation name.
     * @param left Left operand (array).
     * @param right Right operaand (scalar).
     * @returns Result of operation.
     */
    static MultiArrayOpScalar(op: TBinaryOperationName, left: MultiArray, right: ComplexDecimal): MultiArray;
    /**
     * Unary left operation.
     * @param op Unary operation name.
     * @param right Operand (array)
     * @returns Result of operation.
     */
    static leftOperation(op: TUnaryOperationLeftName, right: MultiArray): MultiArray;
    /**
     * Binary element-wise operatior.
     * @param op Binary operatior.
     * @param left Left operand.
     * @param right Right operand.
     * @returns Binary element-wise result.
     */
    static elementWiseOperation(op: TBinaryOperationName, left: MultiArray, right: MultiArray): MultiArray;
    /**
     * Reduce one dimension of MultiArray putting entire dimension in one
     * element of resulting MultiArray as an Array. The resulting MultiArray
     * cannot be unparsed or used as argument of any other method of
     * MultiArray class.
     * @param dimension Dimension to reduce to Array
     * @param M MultiArray to be reduced.
     * @returns MultiArray reduced.
     */
    static reduceToArray(dimension: number, M: MultiArray): MultiArray;
    /**
     * Contract MultiArray along `dimension` calling callback. This method is
     * analogous to the JavaScript Array.reduce function.
     * @param dimension Dimension to operate callback and contract.
     * @param M Multidimensional array.
     * @param callback Reduce function.
     * @param initial Optional initial value to set as previous in the first
     * call of callback. If not set the previous will be set to the first
     * element of dimension.
     * @returns Multiarray with `dimension` reduced using `callback`.
     */
    static reduce(dimension: number, M: MultiArray, callback: (previous: any, current: any, index?: number) => any, initial?: any): MultiArray | ComplexDecimal;
    /**
     * Return the concatenation of N-D array objects, ARRAY1, ARRAY2, ...,
     * ARRAYN along `dimension` parameter (zero-based).
     * @param dimension Dimension of concatenation.
     * @param fname Function name (for error messages).
     * @param ARRAY Arrays to concatenate.
     * @returns Concatenated arrays along `dimension` parameter.
     */
    static concatenate(dimension: number, fname: string, ...ARRAY: MultiArray[]): MultiArray;
    /**
     * Get selected items from MultiArray by linear indices or subscripts.
     * @param M Matrix.
     * @param id Identifier.
     * @param indexList
     * @returns MultiArray of selected items.
     */
    static getElements(M: MultiArray, id: string, indexList: (ComplexDecimal | MultiArray)[]): MultiArray | ComplexDecimal;
    /**
     * Get selected items from MultiArray by logical indexing.
     * @param M Matrix.
     * @param id Identifier.
     * @param items Logical index.
     * @returns MultiArray of selected items.
     */
    static getElementsLogical(M: MultiArray, id: string, items: MultiArray): MultiArray | ComplexDecimal;
    /**
     * Set selected items from MultiArray by linear index or subscripts.
     * @param nameTable Name Table.
     * @param id Identifier.
     * @param args Linear indices or subscripts.
     * @param right Value to assign.
     */
    static setElements(nameTable: TNameTable, id: string, indexList: (ComplexDecimal | MultiArray)[], right: MultiArray, input?: string, that?: Evaluator): void;
    /**
     * Set selected items from MultiArray by logical indexing.
     * @param nameTable Name Table.
     * @param id Identifier.
     * @param arg Logical index.
     * @param right Value to assign.
     */
    static setElementsLogical(nameTable: TNameTable, id: string, arg: ComplexDecimal[], right: MultiArray): void;
}