import { ComplexDecimal, TBinaryOperationName, TUnaryOperationLeftName } from './complex-decimal';
import { Evaluator, TNameTable } from './evaluator';

/**
 * # MultiArray
 *
 * A multimensional array library.
 */
export class MultiArray {
    /**
     * Dimensions property ([lines, columns, pages, blocks, ...]).
     */
    public dimension: number[];

    /**
     * Dimensions excluding columns getter ([lines, pages, blocks, ...]).
     */
    public get dimensionR(): number[] {
        return [this.dimension[0], ...this.dimension.slice(2)];
    }

    /**
     * Array property.
     */
    public array: ComplexDecimal[][];

    /**
     * Type property.
     */
    public type: number;

    /**
     * Parent node property.
     */
    public 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.
     */
    public constructor(shape?: number[], fill?: any) {
        if (shape) {
            this.dimension = shape.slice();
            MultiArray.removeSingletonTail(this.dimension);
            this.array = new Array(this.dimensionR.reduce((p, c) => p * c, 1));
            if (fill) {
                for (let i = 0; i < this.array.length; i++) {
                    this.array[i] = new Array(this.dimension[1]).fill(fill);
                }
                this.type = fill.type;
            } else {
                for (let i = 0; i < this.array.length; i++) {
                    this.array[i] = new Array(this.dimension[1]).fill({ type: -1 });
                }
                this.type = -1;
            }
        } else {
            this.dimension = [0, 0];
            this.array = [];
            this.type = -1;
        }
    }

    /**
     * Check if object is a MultiArray.
     * @param obj Any object.
     * @returns true if object is a MultiArray. false otherwise.
     */
    public static isThis(obj: any): boolean {
        return 'array' in obj;
    }

    /**
     * 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.
     */
    public static isRowVector(obj: any): boolean {
        return 'array' in obj && obj.dimension[0] === 1;
    }

    /**
     * Set type property in place with maximum value of array items type.
     * @param M MultiArray to set type property.
     */
    public static setType(M: MultiArray): void {
        M.type = Math.max(...M.array.map((row) => Math.max(...row.map((value) => value.type))));
    }

    /**
     * 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.
     */
    public static arrayEquals(a: (boolean | number | string)[], b: (boolean | number | string)[]): boolean {
        return a.length === b.length && a.every((value, index) => value === b[index]);
    }

    /**
     * Returns a one-based range array ([1, 2, ..., length]).
     * @param length Length or last value of range array.
     * @returns Range array.
     */
    public static rangeArray(length: number): number[] {
        const result = [];
        for (let i = 1; i <= length; i++) {
            result.push(i);
        }
        return result;
    }

    /**
     * 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, ...]).
     */
    public static linearIndexToSubscript(dimension: number[], index: number): number[] {
        return dimension.map((dim, i) => (Math.floor(index / dimension.slice(0, i).reduce((p, c) => p * c, 1)) % dim) + 1);
    }

    /**
     * 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.
     */
    public static subscriptToLinearIndex(dimension: number[], subscript: number[]): number {
        return subscript.reduce((p, c, i) => p + (c - 1) * dimension.slice(0, i).reduce((p, c) => p * c, 1), 0);
    }

    /**
     * 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]).
     */
    public static linearIndexToMultiArrayRowColumn(row: number, column: number, index: number): [number, number] {
        const pageLength = row * column;
        const indexPage = index % pageLength;
        return [Math.floor(index / pageLength) * row + (indexPage % row), Math.floor(indexPage / row)];
    }

    /**
     * Converts MultiArray subscript to Multiarray.array subscript.
     * @param dimension MultiArray dimension.
     * @param subscript Subscript.
     * @returns Multiarray.array subscript ([row, column]).
     */
    public static subscriptToMultiArrayRowColumn(dimension: number[], subscript: number[]): [number, number] {
        const index = subscript.reduce((p, c, i) => p + (c - 1) * dimension.slice(0, i).reduce((p, c) => p * c, 1), 0);
        const pageLength = dimension[0] * dimension[1];
        const indexPage = index % pageLength;
        return [Math.floor(index / pageLength) * dimension[0] + (indexPage % dimension[0]), Math.floor(indexPage / dimension[0])];
    }

    /**
     * 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, ...]).
     */
    public static ind2subNumber(dimension: number[], index: number): number[] {
        dimension = [...dimension, index + 1];
        return dimension.map((dim, i) => Math.floor((index - 1) / dimension.slice(0, i).reduce((p, c) => p * c, 1)) % dim).map((d) => d + 1);
    }

    /**
     * Returns the number of elements in M.
     * @param M Multidimensional array.
     * @returns Number of elements in M.
     */
    public static linearLength(M: MultiArray): number {
        return M.array.length * M.dimension[1];
    }

    /**
     * Get dimension at index d of MultiArray M
     * @param M Multiarray.
     * @param d Zero-based dimension index.
     * @returns Dimension d.
     */
    public static getDimension(M: MultiArray, d: number): number {
        return d < M.dimension.length ? M.dimension[d] : 1;
    }

    /**
     * Remove singleton tail of dimension array in place.
     * @param dimension Dimension array.
     */
    public static removeSingletonTail(dimension: number[]): void {
        let i = dimension.length - 1;
        while (dimension[i] === 1 && i > 1) {
            dimension.pop();
            i--;
        }
    }

    /**
     * Append singleton tail of dimension array in place.
     * @param dimension Dimension array.
     * @param length Resulting length of dimension array.
     */
    public static appendSingletonTail(dimension: number[], length: number): void {
        if (length > dimension.length) {
            dimension.push(...new Array(length - dimension.length).fill(1));
        }
    }

    /**
     * Find first non-single dimension.
     * @param M MultiArray.
     * @returns First non-single dimension of `M`.
     */
    public static firstNonSingleDimension(M: MultiArray): number {
        for (let i = 0; i < M.dimension.length; i++) {
            if (M.dimension[i] !== 1) {
                return i;
            }
        }
        return M.dimension.length - 1;
    }

    /**
     * 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.
     */
    public static firstRow(row: any[]): MultiArray {
        const result = new MultiArray([1, row.length]);
        result.array[0] = row;
        return result;
    }

    /**
     * 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.
     */
    public static appendRow(M: MultiArray, row: any[]): MultiArray {
        M.array.push(row);
        M.dimension[0]++;
        return M;
    }

    /**
     * Swap two rows of a MultiArray in place.
     * @param M
     * @param m
     * @param n
     */
    public static swapRows(M: MultiArray, m: number, n: number): void {
        const row = M.array[m];
        M.array[m] = M.array[n];
        M.array[n] = row;
    }

    /**
     * Unparse MultiArray.
     * @param M MultiArray object.
     * @returns String of unparsed MultiArray.
     */
    public static unparse(M: MultiArray): string {
        const unparseRows = (row: any[]) => row.map((value) => global.EvaluatorPointer.Unparse(value)).join() + ';\n';
        let arraystr: string = '';
        if (M.dimension.length > 2) {
            let result = '';
            for (let p = 0; p < M.array.length; p += M.dimension[0]) {
                arraystr = M.array
                    .slice(p, p + M.dimension[0])
                    .map(unparseRows)
                    .join('');
                arraystr = arraystr.substring(0, arraystr.length - 2);
                result += `[\n${arraystr}\n] (:,:,${MultiArray.linearIndexToSubscript(M.dimensionR, p).slice(1).join()})\n`;
            }
            return result;
        } else {
            arraystr = M.array.map(unparseRows).join('');
            arraystr = arraystr.substring(0, arraystr.length - 2);
            return `[\n${arraystr}\n]`;
        }
    }

    /**
     * Unparse MultiArray as MathML language.
     * @param M MultiArray object.
     * @returns String of unparsed MultiArray in MathML language.
     */
    public static unparseMathML(M: MultiArray): string {
        const unparseRows = (row: any[]) => `<mtr>${row.map((value) => `<mtd>${global.EvaluatorPointer.unparserMathML(value)}</mtd>`).join('')}</mtr>`;
        const buildMrow = (rows: string) => `<mrow><mo>[</mo><mtable>${rows}</mtable><mo>]</mo></mrow>`;
        if (M.dimension[0] === 0 && M.dimension[1] === 0) {
            return '<mrow><mo>[</mo><mtable><mspace width="0.5em"/></mtable><mo>]</mo></mrow><mo>(</mo><mn>0</mn><mi>&times;</mi><mn>0</mn><mo>)</mo>';
        }
        if (M.dimension.length > 2) {
            let result = '';
            for (let p = 0; p < M.array.length; p += M.dimension[0]) {
                const array = M.array
                    .slice(p, p + M.dimension[0])
                    .map(unparseRows)
                    .join('');
                const subscript = MultiArray.linearIndexToSubscript(M.dimensionR, p)
                    .slice(1)
                    .map((d) => `<mn>${d}</mn>`)
                    .join('<mo>,</mo>');
                result += `<mtr><mtd><msub>${buildMrow(array)}<mrow><mo>(</mo><mo>:</mo><mo>,</mo><mo>:</mo><mo>,</mo>${subscript}<mo>)</mo></mrow></msub></mtd></mtr>`;
            }
            return `<mtable>${result}</mtable>`;
        } else {
            return buildMrow(M.array.map(unparseRows).join(''));
        }
    }

    /**
     * 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(array: any[][], local: boolean = false, fname: string = '', parent: any): any[][] {
        const result: any[][] = [];
        for (let i = 0, k = 0; i < array.length; i++, k++) {
            result.push([]);
            let h = 1;
            for (let j = 0; j < array[i].length; j++) {
                array[i][j].parent = parent;
                const element = global.EvaluatorPointer.Evaluator(array[i][j], local, fname);
                if ('array' in element) {
                    if (j === 0) {
                        h = element.array.length;
                        result.splice(k, 1, element.array[0]);
                        for (let n = 1; n < h; n++) {
                            result.splice(k + n, 0, element.array[n]);
                        }
                    } else {
                        for (let n = 0; n < element.array.length; n++) {
                            result[k + n].push(...element.array[n]);
                        }
                    }
                } else {
                    result[k][j] = element;
                }
            }
            k += h - 1;
            if (i != 0) {
                if (result[i].length != result[0].length) {
                    throw new EvalError(`vertical dimensions mismatch (${k}x${result[0].length} vs 1x${result[i].length}).`);
                }
            }
        }
        return result;
    }

    /**
     * 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.
     */
    public static evaluate(M: MultiArray, local: boolean = false, fname: string = ''): MultiArray {
        const result: MultiArray = new MultiArray();
        for (let p = 0; p < M.array.length; p += M.dimension[0]) {
            const page = MultiArray.evaluatePage(M.array.slice(p, p + M.dimension[0]), local, fname, result);
            if (p === 0) {
                result.dimension = [page.length, page[0].length, ...M.dimension.slice(2)];
            } else {
                if (result.dimension[0] !== page.length || result.dimension[1] !== page[0].length) {
                    throw new EvalError(`page dimensions mismatch (${result.dimension[0]}x${result.dimension[1]} vs ${page.length}x${page[0].length}).`);
                }
            }
            for (let i = 0; i < page.length; i++) {
                result.array[p + i] = page[i];
            }
        }
        MultiArray.setType(result);
        return result;
    }

    /**
     * Linearize MultiArray in an array of any using column-major
     * order.
     * @param M Multidimensional array.
     * @returns `any[]` of multidimensional array `M` linearized.
     */
    public static linearize(M: MultiArray | any): any[] {
        if ('array' in M) {
            const result: any[] = [];
            for (let p = 0; p < M.array.length; p += M.dimension[0]) {
                for (let j = 0; j < M.dimension[1]; j++) {
                    result.push(...M.array.slice(p, p + M.dimension[0]).map((row: any[]) => row[j]));
                }
            }
            return result;
        } else {
            return [M];
        }
    }

    /**
     * Returns a null array (0x0 matrix).
     * @returns Null array (0x0 matrix).
     */
    public static array_0x0(): MultiArray {
        return new MultiArray([0, 0]);
    }

    /**
     * Convert a scalar value to 1x1 MultiArray.
     * @param value MultiArray or scalar.
     * @returns MultiArray 1x1 if value is scalar.
     */
    public static scalarToMultiArray(value: MultiArray | any): MultiArray {
        if ('array' in value) {
            return value;
        } else {
            const result = new MultiArray([1, 1]);
            result.array[0] = [value];
            result.type = value.type;
            return result;
        }
    }

    /**
     * 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.
     */
    public static MultiArrayToScalar(value: MultiArray | any): MultiArray | any {
        if ('array' in value && value.dimension.length === 2 && value.dimension[0] === 1 && value.dimension[1] === 1) {
            return value.array[0][0];
        } else {
            return value;
        }
    }

    /**
     * If `value` parameter is a MultiArray returns it's first element.
     * Otherwise returns `value` parameter.
     * @param value
     * @returns
     */
    public static firstElement(value: MultiArray | any): any {
        if ('array' in value) {
            if (value.dimension.reduce((p: number, c: number) => p * c, 1) > 0) {
                return value.array[0][0];
            } else {
                throw new Error('Cannot get first element of array. Array is [](0x0).');
            }
        } else {
            return value;
        }
    }

    /**
     * Converts a ComplexDecimal array or a single line MultiArray to an array
     * or number.
     * @param M
     * @returns
     */
    public static oneRowToDim(M: ComplexDecimal[] | MultiArray): number[] {
        if (Array.isArray(M)) {
            return M.map((data) => data.re.toNumber());
        } else {
            return M.array[0].map((data) => data.re.toNumber());
        }
    }

    /**
     * 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.
     */
    public static newFilled(fill: any, ...dimension: any): MultiArray | ComplexDecimal {
        if (dimension.length === 0) {
            return fill;
        } else if (dimension.length === 1) {
            if ('array' in dimension[0]) {
                return MultiArray.MultiArrayToScalar(new MultiArray(MultiArray.oneRowToDim(dimension[0]), fill));
            } else {
                return MultiArray.MultiArrayToScalar(new MultiArray([dimension[0].re.toNumber(), dimension[0].re.toNumber()], fill));
            }
        } else {
            return MultiArray.MultiArrayToScalar(new MultiArray(MultiArray.oneRowToDim(dimension), fill));
        }
    }

    /**
     * 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.
     */
    public static newFilledEach(fillFunction: (index: number) => any, ...dimension: any): MultiArray | ComplexDecimal {
        let result: MultiArray;
        if (dimension.length === 0) {
            return fillFunction(0);
        } else if (dimension.length === 1) {
            if ('array' in dimension[0]) {
                result = new MultiArray(MultiArray.oneRowToDim(dimension[0]));
            } else {
                result = new MultiArray([dimension[0].re.toNumber(), dimension[0].re.toNumber()]);
            }
        } else {
            result = new MultiArray(MultiArray.oneRowToDim(dimension));
        }
        for (let n = 0; n < MultiArray.linearLength(result); n++) {
            const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(result.dimension[0], result.dimension[1], n);
            result.array[i][j] = fillFunction(n);
        }
        MultiArray.setType(result);
        return MultiArray.MultiArrayToScalar(result);
    }

    /**
     * Copy of MultiArray.
     * @param M MultiArray.
     * @returns Copy of MultiArray.
     */
    public static copy(M: MultiArray): MultiArray {
        const result = new MultiArray(M.dimension);
        result.array = M.array.map((row) => row.map((value) => (ComplexDecimal.isThis(value) ? ComplexDecimal.copy(value) : Object.assign({}, value))));
        result.type = M.type;
        return result;
    }

    /**
     * Convert MultiArray to logical value. It's true if all elements is
     * non-null. Otherwise is false.
     * @param M
     * @returns
     */
    public static toLogical(M: MultiArray): ComplexDecimal {
        for (let i = 0; i < M.array.length; i++) {
            const row = M.array[i];
            for (let j = 0; j < M.dimension[1]; j++) {
                const value = ComplexDecimal.toMaxPrecision(row[j]);
                if (value.re.eq(0) && value.im.eq(0)) {
                    return ComplexDecimal.false();
                }
            }
        }
        return ComplexDecimal.true();
    }

    /**
     * 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
     */
    public static map(M: MultiArray, f: Function): MultiArray {
        const result = new MultiArray(M.dimension);
        result.array = M.array.map((row) => row.map(f as any));
        MultiArray.setType(result);
        return result;
    }

    /**
     * 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.
     */
    public static expand(M: MultiArray, dim: number[]): void {
        let dimM = M.dimension.slice();
        let dimension = dim.slice();
        if (dimM.length < dimension.length) {
            dimM = dimM.concat(new Array(dimension.length - dimM.length).fill(1));
        }
        if (dimension.length < dimM.length) {
            dimension = dimension.concat(new Array(dimM.length - dimension.length).fill(1));
        }
        const resultDimension = dimension.map((d, i) => Math.max(d, dimM[i]));
        if (MultiArray.arrayEquals(dimM, resultDimension)) {
            return;
        }
        const result = new MultiArray(resultDimension, ComplexDecimal.zero());
        for (let n = 0; n < MultiArray.linearLength(M); n++) {
            const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(M.dimension[0], M.dimension[1], n);
            const subscriptM = MultiArray.linearIndexToSubscript(M.dimension, n);
            const [p, q] = MultiArray.subscriptToMultiArrayRowColumn(result.dimension, subscriptM);
            result.array[p][q] = M.array[i][j];
        }
        MultiArray.removeSingletonTail(result.dimension);
        M.dimension = result.dimension;
        M.array = result.array;
    }

    /**
     * Expand range.
     * @param startNode Start of range.
     * @param stopNode Stop of range.
     * @param strideNode Optional stride value.
     * @returns MultiArray of range expanded.
     */
    public static expandRange(startNode: ComplexDecimal, stopNode: ComplexDecimal, strideNode?: ComplexDecimal | null): MultiArray {
        const expanded = [];
        const s = strideNode ? strideNode.re.toNumber() : 1;
        for (let n = startNode.re.toNumber(), i = 0; s > 0 ? n <= stopNode.re.toNumber() : n >= stopNode.re.toNumber(); n += s, i++) {
            expanded[i] = new ComplexDecimal(n);
        }
        const result = new MultiArray([1, expanded.length]);
        result.array = [expanded];
        MultiArray.setType(result);
        return result;
    }

    /**
     * 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.
     */
    public static testIndex(k: ComplexDecimal, input?: string): number {
        if (!k.re.isInteger() || k.re.lt(1)) {
            throw new RangeError(`${input ? `${input}: ` : ``}subscripts must be either integers greater than or equal 1 or logicals.`);
        }
        if (!k.im.eq(0)) {
            throw new RangeError(`${input ? `${input}: ` : ``}subscripts must be real.`);
        }
        return k.re.toNumber();
    }

    /**
     * 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.
     */
    public static testIndexBound(k: ComplexDecimal, bound: number, dim: number[], input?: string): number {
        const result = MultiArray.testIndex(k, input);
        if (result > bound) {
            throw new RangeError(`${input ? `${input}: ` : ``}out of bound ${bound} (dimensions are ${dim.join('x')}).`);
        }
        return result;
    }

    /**
     * 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.
     */
    public static parseSubscript(dimension: number[], subscript: ComplexDecimal[], input?: string, that?: Evaluator): number {
        // Converts ComplexDecimal[] subscript parameter to number[].
        const index = subscript.map((i) => MultiArray.testIndex(i, `${input ? input : ''}${that ? '(' + subscript.map((i) => that.Unparse(i)).join() + ')' : ''}`));
        /**
         * Throws comprehensive out of bound error indicating subscript index and bound.
         * @param indexPosition Position of subscript index out of bound.
         * @param bound Bound.
         */
        const throwError = (indexPosition: number, bound: number): void => {
            /**
             * Create notation to denote irrelevant subscripts. Returns `'_,_,_,_'`
             * with `length` `'_'` elements or `'...[x${length}]...'` if length > 4.
             * @param length Length of notation.
             * @returns String notation.
             */
            const irrelevantSubscript = (length: number): string => {
                return length > 4 ? `...[x${length}]...` : new Array(length).fill('_').join();
            };
            const left = irrelevantSubscript(indexPosition);
            const right = irrelevantSubscript(index.length - indexPosition - 1);
            throw new RangeError(
                `${input ? input : ''}(${left}${!!left ? ',' : ''}${index[indexPosition]}${!!right ? ',' : ''}${right}): out of bound ${bound} (dimensions are ${dimension.join(
                    'x',
                )}).`,
            );
        };
        // Copy index to indexReduced and remove singleton tail.
        const indexReduced = index.slice();
        MultiArray.removeSingletonTail(indexReduced);
        if (indexReduced.length > dimension.length) {
            // Error if indexReduced has more dimensions than dimension parameter.
            const test = index.map((i, n) => i > dimension[n]);
            const dimFail = test.indexOf(true);
            if (dimFail >= 0) {
                throwError(dimFail, 1);
            }
        }
        let dim: number[];
        if (index.length < dimension.length) {
            // Copy dimension parameter.
            dim = dimension.slice();
            // Test if some index greater than dim.
            const test = index.map((i, n) => i > dimension[n]);
            const dimFail = test.indexOf(true);
            if (dimFail >= 0) {
                if (dimFail === index.length - 1) {
                    // Last index is greater than corresponding dimension. Test if it's greater than dimension tail.
                    const bound = dim.slice(index.length - 1).reduce((p, c) => p * c, 1);
                    if (index[index.length - 1] > bound) {
                        throwError(dimFail, bound);
                    }
                } else {
                    // Error before last index.
                    throwError(dimFail, dim[dimFail]);
                }
            }
        } else {
            // Copy dimension parameter and append 1 until it has the same length of index if necessary.
            dim = dimension.concat(new Array(index.length - dimension.length).fill(1));
            // Test if some index greater than dim.
            const test = index.map((i, n) => i > dimension[n]);
            const dimFail = test.indexOf(true);
            if (dimFail >= 0) {
                throwError(dimFail, dim[dimFail]);
            }
        }
        return indexReduced.reduce((p, c, i) => p + (c - 1) * dimension.slice(0, i).reduce((p, c) => p * c, 1), 0);
    }

    /**
     * Binary operation 'scalar `operation` array'.
     * @param op Binary operation name.
     * @param left Left operand (scalar).
     * @param right Right operand (array).
     * @returns Result of operation.
     */
    public static scalarOpMultiArray(op: TBinaryOperationName, left: ComplexDecimal, right: MultiArray): MultiArray {
        const result = new MultiArray(right.dimension);
        result.array = right.array.map((row) => row.map((value) => ComplexDecimal[op](left, value)));
        MultiArray.setType(result);
        return result;
    }

    /**
     * Binary operation 'array `operation` scalar'.
     * @param op Binary operation name.
     * @param left Left operand (array).
     * @param right Right operaand (scalar).
     * @returns Result of operation.
     */
    public static MultiArrayOpScalar(op: TBinaryOperationName, left: MultiArray, right: ComplexDecimal): MultiArray {
        const result = new MultiArray(left.dimension);
        result.array = left.array.map((row) => row.map((value) => ComplexDecimal[op](value, right)));
        MultiArray.setType(result);
        return result;
    }

    /**
     * Unary left operation.
     * @param op Unary operation name.
     * @param right Operand (array)
     * @returns Result of operation.
     */
    public static leftOperation(op: TUnaryOperationLeftName, right: MultiArray): MultiArray {
        const result = new MultiArray(right.dimension);
        result.array = right.array.map((row) => row.map((value) => ComplexDecimal[op](value)));
        MultiArray.setType(result);
        return result;
    }

    /**
     * Binary element-wise operatior.
     * @param op Binary operatior.
     * @param left Left operand.
     * @param right Right operand.
     * @returns Binary element-wise result.
     */
    public static elementWiseOperation(op: TBinaryOperationName, left: MultiArray, right: MultiArray): MultiArray {
        let leftDimension = left.dimension.slice();
        let rightDimension = right.dimension.slice();
        if (leftDimension.length < rightDimension.length) {
            leftDimension = leftDimension.concat(new Array(rightDimension.length - leftDimension.length).fill(1));
        }
        if (rightDimension.length < leftDimension.length) {
            rightDimension = rightDimension.concat(new Array(leftDimension.length - rightDimension.length).fill(1));
        }
        if (MultiArray.arrayEquals(leftDimension, rightDimension)) {
            // No broadcasting.
            const result = new MultiArray(leftDimension);
            result.array = left.array.map((row, i) => row.map((value, j) => ComplexDecimal[op](value, right.array[i][j])));
            MultiArray.setType(result);
            return result;
        } else {
            // Broadcasting
            const leftBroadcast = new Array(leftDimension.length);
            const rightBroadcast = new Array(rightDimension.length);
            const resultDimension = new Array(leftDimension.length);
            for (let d = 0; d < leftDimension.length; d++) {
                if (leftDimension[d] === rightDimension[d]) {
                    leftBroadcast[d] = false;
                    rightBroadcast[d] = false;
                    resultDimension[d] = leftDimension[d];
                } else if (leftDimension[d] === 1) {
                    leftBroadcast[d] = true;
                    rightBroadcast[d] = false;
                    resultDimension[d] = rightDimension[d];
                } else if (rightDimension[d] === 1) {
                    leftBroadcast[d] = false;
                    rightBroadcast[d] = true;
                    resultDimension[d] = leftDimension[d];
                } else {
                    throw new EvalError(`operator ${op}: nonconformant arguments (op1 is ${left.dimension.join('x')}, op2 is ${right.dimension.join('x')}).`);
                }
            }
            const result = new MultiArray(resultDimension);
            const resultLinearLength = MultiArray.subscriptToLinearIndex(resultDimension, resultDimension) + 1;
            for (let n = 0; n < resultLinearLength; n++) {
                const resultSubscript = MultiArray.linearIndexToSubscript(resultDimension, n);
                const leftSubscript = resultSubscript.map((s, i) => (leftBroadcast[i] ? 1 : s));
                const leftLinear = MultiArray.subscriptToLinearIndex(leftDimension, leftSubscript);
                const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(leftDimension[0], leftDimension[1], leftLinear);
                const rightSubscript = resultSubscript.map((s, i) => (rightBroadcast[i] ? 1 : s));
                const rightLinear = MultiArray.subscriptToLinearIndex(rightDimension, rightSubscript);
                const [k, l] = MultiArray.linearIndexToMultiArrayRowColumn(rightDimension[0], rightDimension[1], rightLinear);
                const [o, p] = MultiArray.linearIndexToMultiArrayRowColumn(resultDimension[0], resultDimension[1], n);
                result.array[o][p] = ComplexDecimal[op](left.array[i][j], right.array[k][l]);
            }
            MultiArray.setType(result);
            return result;
        }
    }

    /**
     * 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.
     */
    public static reduceToArray(dimension: number, M: MultiArray): MultiArray {
        if (dimension >= M.dimension.length) {
            return M;
        } else {
            const dimResult = M.dimension.slice();
            dimResult[dimension] = 1;
            const result = new MultiArray(dimResult);
            const subscriptC = M.dimension.slice();
            subscriptC[dimension] = 1;
            const length = subscriptC.reduce((p, c) => p * c, 1);
            for (let d = 1; d <= M.dimension[dimension]; d++) {
                const subscriptC = M.dimension.slice();
                subscriptC[dimension] = 1;
                const args = subscriptC.map((s) => MultiArray.rangeArray(s));
                args[dimension] = [d];
                for (let n = 0; n < length; n++) {
                    const subscriptM = MultiArray.linearIndexToSubscript(subscriptC, n).map((s, r) => args[r][s - 1]);
                    const linearM = MultiArray.subscriptToLinearIndex(M.dimension, subscriptM);
                    const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(M.dimension[0], M.dimension[1], linearM);
                    const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(result.dimension[0], result.dimension[1], n);
                    if (d === 1) {
                        result.array[p][q] = [M.array[i][j]] as unknown as ComplexDecimal;
                    } else {
                        (result.array[p][q] as unknown as ComplexDecimal[]).push(M.array[i][j]);
                    }
                }
            }
            result.type = M.type;
            return result;
        }
    }

    /**
     * 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`.
     */
    public static reduce(dimension: number, M: MultiArray, callback: (previous: any, current: any, index?: number) => any, initial?: any): MultiArray | ComplexDecimal {
        if (dimension >= M.dimension.length) {
            return M;
        } else {
            const dimResult = M.dimension.slice();
            dimResult[dimension] = 1;
            const result = new MultiArray(dimResult);
            const subscriptC = M.dimension.slice();
            subscriptC[dimension] = 1;
            const length = subscriptC.reduce((p, c) => p * c, 1);
            const args = subscriptC.map((s) => MultiArray.rangeArray(s));
            for (let n = 0; n < length; n++) {
                const subscriptM = MultiArray.linearIndexToSubscript(subscriptC, n).map((s, r) => args[r][s - 1]);
                const linearM = MultiArray.subscriptToLinearIndex(M.dimension, subscriptM);
                const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(M.dimension[0], M.dimension[1], linearM);
                const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(result.dimension[0], result.dimension[1], n);
                result.array[p][q] = initial ? callback(initial, M.array[i][j], n) : M.array[i][j];
            }
            for (let d = 2; d <= M.dimension[dimension]; d++) {
                const subscriptC = M.dimension.slice();
                subscriptC[dimension] = 1;
                const args = subscriptC.map((s) => MultiArray.rangeArray(s));
                args[dimension] = [d];
                for (let n = 0; n < length; n++) {
                    const subscriptM = MultiArray.linearIndexToSubscript(subscriptC, n).map((s, r) => args[r][s - 1]);
                    const linearM = MultiArray.subscriptToLinearIndex(M.dimension, subscriptM);
                    const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(M.dimension[0], M.dimension[1], linearM);
                    const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(result.dimension[0], result.dimension[1], n);
                    const subscriptP = MultiArray.linearIndexToSubscript(result.dimension, n);
                    subscriptP[dimension] = 1;
                    const [r, s] = MultiArray.subscriptToMultiArrayRowColumn(result.dimension, subscriptP);
                    result.array[p][q] = callback(result.array[r][s], M.array[i][j], n);
                }
            }
            MultiArray.setType(result);
            return MultiArray.MultiArrayToScalar(result);
        }
    }

    /**
     * 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.
     */
    public static concatenate(dimension: number, fname: string, ...ARRAY: MultiArray[]): MultiArray {
        // Get all ARRAY dimension and set 0 at dimension[dimension]
        const catDims: number[] = [];
        const dims = ARRAY.map((array) => {
            const dim = array.dimension.slice();
            MultiArray.appendSingletonTail(dim, dimension + 1);
            catDims.push(dim[dimension]);
            dim[dimension] = 0;
            return dim;
        });
        // Check if all ARRAY dimensions are equals except for dimension parameter.
        if (!dims.every((dim) => MultiArray.arrayEquals(dim, dims[0]))) {
            throw new EvalError(`${fname}: dimension mismatch`);
        }
        const resultDim = dims[0].slice();
        resultDim[dimension] = catDims.reduce((p, c) => p + c, 0);
        const result = new MultiArray(resultDim);
        ARRAY.forEach((array, a) => {
            const shift = catDims.slice(0, a).reduce((p, c) => p + c, 0);
            for (let n = 0; n < MultiArray.linearLength(array); n++) {
                const arrayDim = array.dimension.slice();
                MultiArray.appendSingletonTail(arrayDim, dimension + 1);
                const subscript = MultiArray.linearIndexToSubscript(arrayDim, n);
                subscript[dimension] += shift;
                const [i, j] = MultiArray.subscriptToMultiArrayRowColumn(result.dimension, subscript);
                const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(array.dimension[0], array.dimension[1], n);
                result.array[i][j] = array.array[p][q];
            }
        });
        MultiArray.setType(result);
        return result;
    }

    /**
     * Get selected items from MultiArray by linear indices or subscripts.
     * @param M Matrix.
     * @param id Identifier.
     * @param indexList
     * @returns MultiArray of selected items.
     */
    public static getElements(M: MultiArray, id: string, indexList: (ComplexDecimal | MultiArray)[]): MultiArray | ComplexDecimal {
        let result: MultiArray;
        if (indexList.length === 0) {
            return M;
        } else {
            const args = indexList.map((index) => MultiArray.linearize(index));
            const argsLength = args.map((arg) => arg.length);
            if (indexList.length === 1 && 'array' in indexList[0]) {
                result = new MultiArray(indexList[0].dimension);
            } else {
                result = new MultiArray(argsLength.length > 1 ? argsLength : [argsLength[0], 1]);
            }
            for (let n = 0; n < argsLength.reduce((p, c) => p * c, 1); n++) {
                const subscriptM = MultiArray.linearIndexToSubscript(argsLength, n).map((s, r) => args[r][s - 1]);
                const linearM = MultiArray.parseSubscript(M.dimension, subscriptM, id);
                const [i, j] = MultiArray.linearIndexToMultiArrayRowColumn(M.dimension[0], M.dimension[1], linearM);
                const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(result.dimension[0], result.dimension[1], n);
                result.array[p][q] = M.array[i][j];
            }
            MultiArray.setType(result);
            return MultiArray.MultiArrayToScalar(result);
        }
    }

    /**
     * Get selected items from MultiArray by logical indexing.
     * @param M Matrix.
     * @param id Identifier.
     * @param items Logical index.
     * @returns MultiArray of selected items.
     */
    public static getElementsLogical(M: MultiArray, id: string, items: MultiArray): MultiArray | ComplexDecimal {
        const result = new MultiArray();
        const linM = MultiArray.linearize(M);
        const test = MultiArray.linearize(items).map((value: ComplexDecimal) => value.re.toNumber());
        if (test.length > linM.length) {
            const dimM = M.dimension.slice();
            throw new EvalError(`${id}(${test.length}): out of bound ${linM.length} (dimensions are ${dimM.join('x')})`);
        }
        for (let n = 0; n < linM.length; n++) {
            if (test[n]) {
                result.array.push([linM[n]]);
            }
        }
        result.dimension = [result.array.length, 1];
        return MultiArray.MultiArrayToScalar(result);
    }

    /**
     * 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.
     */
    public static setElements(nameTable: TNameTable, id: string, indexList: (ComplexDecimal | MultiArray)[], right: MultiArray, input?: string, that?: Evaluator): void {
        if (indexList.length === 0) {
            throw new RangeError('invalid empty index list.');
        } else {
            const linright = MultiArray.linearize(right);
            const isLinearIndex = indexList.length === 1;
            const args = indexList.map((index) => MultiArray.linearize(index));
            const argsLength = args.map((arg) => arg.length);
            const argsParsed = args.map((arg) =>
                arg.map((i) => MultiArray.testIndex(i, `${input ? input : ''}${that ? '(' + args.map((arg) => arg.map((i) => that.Unparse(i))).join() + ')' : ''}`)),
            );
            const argsMax = argsParsed.map((arg) => Math.max(...arg));
            if (linright.length !== 1 && linright.length !== argsLength.reduce((p, c) => p * c, 1)) {
                throw new RangeError(`=: nonconformant arguments (op1 is ${argsLength.join('x')}, op2 is ${right.dimension.join('x')})`);
            }
            if (typeof nameTable[id] !== 'undefined' && 'array' in nameTable[id].expr) {
                if (isLinearIndex) {
                    if (argsMax[0] > MultiArray.linearLength(nameTable[id].expr)) {
                        throw new RangeError('Invalid resizing operation or ambiguous assignment to an out-of-bounds array element.');
                    }
                } else {
                    MultiArray.expand(nameTable[id].expr, argsMax);
                }
            } else {
                if (isLinearIndex) {
                    nameTable[id] = {
                        args: [],
                        expr: new MultiArray([1, argsMax[0]], ComplexDecimal.zero()),
                    };
                } else {
                    nameTable[id] = {
                        args: [],
                        expr: new MultiArray(argsMax, ComplexDecimal.zero()),
                    };
                }
            }
            const array: MultiArray = nameTable[id].expr;
            const dimension: number[] = nameTable[id].expr.dimension.slice();
            for (let n = 0; n < argsLength.reduce((p, c) => p * c, 1); n++) {
                const subscript = MultiArray.linearIndexToSubscript(argsLength, n);
                const subscriptArgs: number[] = subscript.map((s, r) =>
                    MultiArray.testIndex(args[r][s - 1], `${input ? input : ''}${that ? '(' + subscript.map((i) => that.Unparse(new ComplexDecimal(i))).join() + ')' : ''}`),
                );
                const indexLinear = MultiArray.subscriptToLinearIndex(dimension, subscriptArgs);
                const [p, q] = MultiArray.linearIndexToMultiArrayRowColumn(dimension[0], dimension[1], indexLinear);
                array.array[p][q] = linright.length === 1 ? linright[0] : linright[n];
            }
        }
    }

    /**
     * Set selected items from MultiArray by logical indexing.
     * @param nameTable Name Table.
     * @param id Identifier.
     * @param arg Logical index.
     * @param right Value to assign.
     */
    public static setElementsLogical(nameTable: TNameTable, id: string, arg: ComplexDecimal[], right: MultiArray): void {
        const linright = MultiArray.linearize(right);
        const test = arg.map((value: ComplexDecimal) => value.re.toNumber());
        const testCount = test.reduce((p, c) => p + c, 0);
        if (testCount !== linright.length) {
            throw new EvalError(`=: nonconformant arguments (op1 is ${testCount}x1, op2 is ${right.dimension[0]}x${right.dimension[1]})`);
        }
        const isDefinedId = typeof nameTable[id] !== 'undefined';
        const isNotFunction = isDefinedId && nameTable[id].args.length === 0;
        const isMultiArray = isNotFunction && 'array' in nameTable[id].expr;
        if (isMultiArray) {
            for (let j = 0, n = 0, r = 0; j < nameTable[id].expr.dimension[1]; j++) {
                for (let i = 0; i < nameTable[id].expr.dimension[0]; i++, r++) {
                    if (test[r]) {
                        nameTable[id].expr.array[i][j] = linright[n];
                        n++;
                    }
                }
            }
        } else {
            throw new EvalError(`${id}(_): invalid matrix indexing.`);
        }
    }
}