import type { MatrixLike, Tuple } from "../types";
export type MatrixOperand<M extends number, N extends number> = Matrix<M, N> | MatrixLike<M, N> | number[][];
export type SubmatrixOptions = {
    removeRows: number[];
    removeCols: number[];
    xywh?: never;
} | {
    xywh: [number, number] | [number, number, number, number];
    removeRows?: never;
    removeCols?: never;
};
type MatrixResult<M extends number, N extends number, I extends MatrixOperand<number, number> | number> = I extends number ? Matrix<M, N> : I extends MatrixOperand<infer O, infer P> ? N extends O ? Matrix<M, P> : never : never;
export type MTXOptions = {
    format?: "coordinate" | "array";
    field?: "real" | "complex" | "integer" | "pattern";
    symmetry?: "general" | "symmetric" | "skew-symmetric" | "hermitian";
};
/**
 * A concrete Matrix class for simple linear algebra, currently only supporting
 * simple numbers, but with plans to add support for complex numbers.
 *
 * Implements {@link Iterable} over {@link Tuple}
 */
export declare class Matrix<M extends number = number, N extends number = number> implements Iterable<Tuple<number, N>> {
    #private;
    constructor(data: MatrixLike<M, N>);
    get rows(): M;
    get cols(): N;
    get size(): number;
    get data(): MatrixLike<M, N>;
    static zero<N extends number>(n: N): Matrix<N, N>;
    static identity<N extends number>(n: N): Matrix<N, N>;
    static withSize<M extends number, N extends number>(rows: M, cols: N, fillValue?: number): Matrix<M, N>;
    static fromDiagonal<N extends number>(diagonal: Tuple<number, N> | number[]): Matrix<N, N>;
    static fromMTX<M extends number, N extends number>(data: string, options?: MTXOptions): Matrix<M, N>;
    static isMatrixLike<M extends number, N extends number>(arg: unknown, ...dimensions: [m: M, n: N] | []): arg is MatrixLike<M, N>;
    isSquare(): boolean;
    isOrthogonal(): boolean;
    at(i: number, j: number): number | undefined;
    row(i: number): Tuple<number, N> | undefined;
    col(j: number): Tuple<number, M> | undefined;
    clone(): Matrix<M, N>;
    submatrix<M extends number, N extends number>({ removeRows, removeCols, xywh, }: SubmatrixOptions): Matrix<M, N>;
    trace(): number;
    determinant(): number | undefined;
    augment<O extends number, P extends number>(other: MatrixOperand<M, O>): Matrix<M, P>;
    inverse(tolerance?: number): Matrix<M, M> | undefined;
    transpose(): Matrix<N, M>;
    vectorize(): number[];
    add(other: MatrixOperand<M, N>): Matrix<M, N>;
    sub(other: MatrixOperand<M, N>): Matrix<M, N>;
    mul<I extends MatrixOperand<number, number> | number>(other: I): MatrixResult<M, N, I>;
    pow(k: number): Matrix<M, M>;
    eq(other: MatrixOperand<M, N>, tolerance?: number): boolean;
    dot(other: MatrixOperand<M, 1>): number;
    [Symbol.iterator](): IterableIterator<Tuple<number, N>>;
}
export {};