import * as IO from 'fp-ts/IO';
import * as M from './Matrix';
import * as MatTypes from './MatrixTypes';
import * as V from './Vector';
import * as C from './Computation';
/**
 * @since 1.0.0
 * @category Model
 */
export interface Decomposition<N, M, R, A> {
    input: M.Mat<N, M, R>;
    result: A;
}
/**
 * Represents the result of a computation that can solve:
 *
 * ```math
 * Ax = b
 * ```
 *
 * @since 1.0.4
 * @category Model
 */
export interface Solvable<M, R> {
    solve: (b: V.Vec<M, R>) => V.Vec<M, R>;
}
/**
 * Represents the result of a computation that can be used to calculate the determinant
 *
 * @since 1.0.4
 * @category Model
 */
export interface Determinant {
    det: IO.IO<number>;
}
/**
 * Represents a solution to an overdetermined system. Returns O.none if the `rank(A) < m`
 * (the number of columns). Returns a tuple with the residual, and solution vector
 *
 * @since 1.1.0
 * @category Model
 */
export interface LeastSquares<N, M, R> {
    solve: (b: V.Vec<N, R>) => C.Computation<string, [number, V.Vec<M, R>]>;
}
/**
 * Determines if `A` is singular
 *
 * @since 1.1.0
 * @category Model
 */
export interface IsSingular {
    isSingular: boolean;
}
/**
 * Returns the Rank of A
 *
 * @since 1.1.0
 * @category Model
 */
export interface Rank {
    rank: number;
}
/**
 * Decomposition of a square matrix into a lower triangular matrix L and an upper
 * triangular matrix U, with a permutation matrix P, such that:
 *
 * ```math
 * PA = LU
 * ```
 *
 * @since 1.0.0
 * @category Constructors
 */
export declare const LUP: <M extends number>(m: M.Mat<M, M, number>) => C.Computation<string, Decomposition<M, M, number, [MatTypes.LowerTriangularMatrix<M, number>, MatTypes.UpperTriangularMatrix<M, number>, MatTypes.OrthogonalMatrix<M, number>]> & Solvable<M, number> & Determinant>;
/**
 * QR decomposition with column pivoting using Householder Reflections. Based on an
 * algorithm described in Fundamentals of Matrix Computations, David S. Watkins.
 *
 * Can be used to calculate a matrix's:
 *
 * - Singularity
 * - Rank
 * - Least Square Solution for overdetermined systems
 *
 * Efficiency: `O(n^3)`
 *
 * Returns a tuple with:
 *
 * - `A'`: The assembled matrix R with lower triangular components being orthogonal vectors
 *   collectively used to construct the reflector `Q`.
 * - `Q`: An IO that returns a constructed reflector `Q`. This has the same efficiency as QR
 *   decomposition itself, so evaluation is deferred.
 * - `R`: The upper triangular matrix extracted from `A'`.
 * - `P`: The permutation matrix used to permute the columns of `A`
 *
 * QR decomposes a matrix A into a matrix `Q`, a matrix `R`, and a matrix `P` such that:
 *
 * ```math
 * AP = QR
 * ```
 *
 * @since 1.1.0
 * @category Constructors
 */
export declare function QR<N extends number, M extends number>(mat: M.Mat<N, M, number>): C.Computation<string, Decomposition<N, M, number, [
    M.Mat<N, M, number>,
    IO.IO<MatTypes.OrthogonalMatrix<N, number>>,
    M.Mat<N, M, number>,
    MatTypes.OrthogonalMatrix<M, number>
]> & IsSingular & Rank & LeastSquares<N, M, number>>;
//# sourceMappingURL=Decomposition.d.ts.map