interface LinearSystem {
    coefficients: Matrix;
    independentTerms: number[];
}
type Matrix = number[][];
declare namespace LinearSystems {
    interface LUMatrices {
        l: Matrix;
        u: Matrix;
    }
    type LUComposition = (data: LUMatrices) => Matrix;
    namespace LUDecomposition {
        type Doolittle = (data: Matrix) => LUDecomposition.Doolittle.Return;
        namespace Doolittle {
            interface Return {
                result: LUMatrices;
            }
        }
    }
    type GaussianElimination = (data: LinearSystem) => GaussianElimination.Return;
    namespace GaussianElimination {
        type Result = Record<string, number>;
        interface Step {
            coefficients: string[];
            independentTerms: string[];
        }
        type TransformedFuncs = string[];
        interface Details {
            steps: Step[];
            transformedFuncs: TransformedFuncs;
        }
        type Return = {
            result: Result;
            details: Details;
        };
    }
    type GaussMethod = (data: GaussMethod.Params) => GaussMethod.Return;
    namespace GaussMethod {
        type Params = LinearSystem & {
            precision: number;
            options?: {
                /** Maximum number of iterations. */
                maxIterations?: number;
            };
        };
        interface Result {
            iterations: number;
            iterationFunc: string[];
            spectralRadius: number;
            solution: number[];
        }
        type Details = Array<{
            iteration: number;
            currentGuess: number[];
            nextGuess: number[];
            absoluteError: number;
            relativeError: number;
        }>;
        interface Return {
            result: Result;
            details: Details;
        }
    }
}
declare const luCompositionParams: {
    l: string;
    u: string;
};
declare const luComposition: LinearSystems.LUComposition;
declare const doolittleLuDecompositionParams: {
    matrix: string;
};
declare const doolittleLuDecomposition: LinearSystems.LUDecomposition.Doolittle;
declare const gaussianEliminationParams: {
    coefficients: string;
    independentTerms: string;
};
declare const gaussianElimination: LinearSystems.GaussianElimination;
declare const spectralRadiusParams: {
    coefficients: string;
};
declare const spectralRadius: (coefficients: Matrix) => number;
declare const gaussMethodParams: {
    precision: string;
    options: {
        maxIterations: string;
    };
    coefficients: string;
    independentTerms: string;
};
declare const gaussJacobi: LinearSystems.GaussMethod;
declare const gaussSeidel: LinearSystems.GaussMethod;

export { type LinearSystem, LinearSystems, type Matrix, doolittleLuDecomposition, doolittleLuDecompositionParams, gaussJacobi, gaussMethodParams, gaussSeidel, gaussianElimination, gaussianEliminationParams, luComposition, luCompositionParams, spectralRadius, spectralRadiusParams };