import { ComplexType } from './Complex';
import { MultiArray } from './MultiArray';
import { Evaluator } from './Evaluator';
declare const EXPECT_TOL = 1e-14;
declare const MAX_ITERACTION = 1000;
declare const DEFAULT_EIG_TOL = 1e-14;
interface TestOptions {
    maxIter?: number;
    tol?: number;
    real?: boolean;
    frobenius?: boolean;
    print?: boolean;
    Aid?: string;
    Bid?: string;
    Cid?: string;
    Did?: string;
    Eid?: string;
    Fid?: string;
    Gid?: string;
    Hid?: string;
    Iid?: string;
    Jid?: string;
    Kid?: string;
    Lid?: string;
    Mid?: string;
    Nid?: string;
    Oid?: string;
    Pid?: string;
    Qid?: string;
    Rid?: string;
    Sid?: string;
    Tid?: string;
    Uid?: string;
    Vid?: string;
    Wid?: string;
    Xid?: string;
    Yid?: string;
    Zid?: string;
}
interface TestResult {
    dim?: number[];
    norm?: number;
    maxErr?: number;
    expression?: string;
}
declare const defaulTestOptions: TestOptions;
declare abstract class LAPACKtest {
    static readonly setTestOptions: (options?: TestOptions) => TestOptions;
    static readonly rand: () => number;
    static readonly randomReal: () => ComplexType;
    static readonly randomComplex: () => ComplexType;
    static readonly randomHermitian: (n: number, real?: boolean) => ComplexType[][];
    static readonly frobenius_norm: (M: MultiArray | ComplexType[][]) => number;
    static readonly print_matrix: (M: MultiArray | ComplexType[][], Mid?: string, evaluator?: Evaluator) => void;
    static array_to_multiarray: (M: MultiArray | ComplexType[][]) => MultiArray;
    static array_or_vector_to_diagonal_multiarray: (M: MultiArray | ComplexType[][] | ComplexType[]) => MultiArray;
    static readonly testHermitian: (A: MultiArray | ComplexType[][], options?: TestOptions) => TestResult;
    /**
     * Test unitarity / orthogonality of a matrix:
     *
     *     || Vᴴ V − I ||_F
     */
    static readonly testUnitarity: (V: MultiArray | ComplexType[][], options?: TestOptions) => TestResult;
    static readonly testOrthogonal: (V: MultiArray | ComplexType[][], options?: TestOptions) => TestResult;
    /**
     * Test that eigenvalues are (numerically) real:
     *
     *     max |Im(λᵢ)|
     */
    static readonly testRealEigenvalues: (D: MultiArray | ComplexType[][] | ComplexType[], options?: TestOptions) => TestResult;
    /**
     * Test diagonality:
     *
     *     || A − diag(A) ||_F
     */
    static readonly testOffDiagonal: (D: MultiArray | ComplexType[][] | ComplexType[], options?: TestOptions) => TestResult;
    /**
     * Test tridiagonality:
     *
     *     || off-tridiagonal(A) ||_F
     */
    static readonly testTridiagonality: (D: MultiArray | ComplexType[][], options?: TestOptions) => TestResult;
    /**
     * Test the eigenvalue decomposition residual:
     *
     *     || A·V − V·D ||_F
     *
     * @param A Original Hermitian matrix
     * @param V Eigenvector matrix
     * @param D Diagonal eigenvalue matrix
     */
    static readonly testEigenResidual: (A: MultiArray | ComplexType[][], V: MultiArray | ComplexType[][], D: MultiArray | ComplexType[][] | ComplexType[], options?: TestOptions) => {
        norm: number;
        maxErr: number;
    } | {
        maxErr: number;
        norm?: undefined;
    };
    /**
     * Test the Hermitian tridiagonal reconstruction:
     *
     *     || A − Q · T · Qᴴ ||_F
     *
     * @param A Original Hermitian matrix
     * @param Q Unitary matrix from UNGTR
     * @param T Tridiagonal matrix
     * @returns Frobenius norm of the reconstruction error
     */
    static readonly testHermitianTridiagonalReconstruction: (A: MultiArray | ComplexType[][], Q: MultiArray | ComplexType[][], T: MultiArray | ComplexType[][], options?: TestOptions) => TestResult;
    static start_test_complex_tridiagonal: () => {
        evaluator: Evaluator;
        D_orig: ComplexType[];
        E_orig: ComplexType[];
        n: number;
    };
    static start_test_complex_tridiagonal_hermitian: () => {
        evaluator: Evaluator;
        D_orig: ComplexType[];
        E_orig: ComplexType[];
        n: number;
        T0: MultiArray;
    };
    /**
     *
     * @returns
     */
    static start_test_complex_tridiagonal_hermitian_to_real2n: () => {
        evaluator: Evaluator;
        D_orig: ComplexType[];
        E_orig: ComplexType[];
        n: number;
        T0: MultiArray;
        T: MultiArray;
    };
    static test_jacobi_hermitian_real2n_final: () => void;
    static test_jacobi_hermitian_real2n: () => void;
    static test_jacobi_hermitian_real2n_direct: () => void;
    static test_jacobi_hermitian_via_real2n: () => void;
    static readonly test_jacobi_complex_hermitian_dense: () => void;
    static test_jacobi_hermitian_full(): void;
    static test_numeric_jacobi_hermitian_direct: () => void;
    static test_apply_givens_tridiagonal: () => void;
    static test_numeric_qr_hermitian_tridiagonal: () => void;
    static test_qr_hermitian_tridiagonal_full(): void;
    /**
     * Teste da seção 7: verifica se Zᴴ·T·Z ≈ T_after para matriz tridiagonal hermitiana
     * @param D ComplexType[] diagonal
     * @param E ComplexType[] subdiagonal
     */
    static readonly test_tridiagonal_similarity: (D: ComplexType[], E: ComplexType[]) => void;
    static readonly test_orthonormality: (V: MultiArray) => {
        maxOffDiag: number;
        maxDiagDeviation: number;
    };
    /**
     * Diagnóstico por autovetor:
     * Para cada coluna j:
     *  - lambda = Dcol[j,0]
     *  - rq = (vᴴ * A * v) / (vᴴ * v)   (Rayleigh quotient)
     *  - res_j = || A*v - lambda*v ||_2   (norma euclidiana do residual)
     *
     * Imprime uma tabela (j, lambda, Re(rq), Im(rq), |lambda - rq|, res_j )
     * @param A
     * @param V
     * @param Dcol
     * @returns
     */
    static readonly diag_eigenpairs: (A: ComplexType[][], V: MultiArray, Dcol: MultiArray) => any[];
    /**
     * Compara listas: ordena autovalores fornecidos e compara com Rayleighs - procura permutações.
     * Retorna um mapeamento aproximado index->index por menor diferença absoluta.
     *
     * Inputs:
     *  - evals: ComplexType[] (autovalores retornados)
     *  - rqs: ComplexType[] (rayleighs calculados para cada coluna v_j)
     *
     * Imprime o pareamento escolhido e as diferenças.
     * @param evals
     * @param rqs
     * @returns
     */
    static readonly match_evals_to_rayleighs: (evals: ComplexType[], rqs: ComplexType[]) => {
        evalIndex: number;
        rqIndex: number;
        diff: number;
    }[];
    static test_numeric_qr_bulge_chasing_hermitian: () => void;
    static test_complex_givens_unitarity: () => void;
    static test_apply_givens_to_Z: () => void;
}
export { type TestOptions, LAPACKtest, EXPECT_TOL, MAX_ITERACTION, DEFAULT_EIG_TOL, defaulTestOptions };
declare const _default: {
    LAPACKtest: typeof LAPACKtest;
};
export default _default;