/**
 * A constrained matrix type. Allows for matrix/vector operations that won't fail due to
 * incompatible shapes
 *
 * @since 1.0.0
 */
import * as Apl from 'fp-ts/Applicative';
import * as Fun from 'fp-ts/Functor';
import * as FunI from 'fp-ts/FunctorWithIndex';
import * as Fl from 'fp-ts/Foldable';
import * as FlI from 'fp-ts/FoldableWithIndex';
import * as IO from 'fp-ts/IO';
import { Kind, Kind2, Kind3, Kind4, URIS, URIS2, URIS3, URIS4 } from 'fp-ts/HKT';
import * as Mn from 'fp-ts/Monoid';
import * as O from 'fp-ts/Option';
import * as Rng from 'fp-ts/Ring';
import * as TC from './typeclasses';
import * as V from './Vector';
/**
 * @since 1.0.0
 * @category Model
 */
export interface Mat<M, N, A> extends V.Vec<M, V.Vec<N, A>> {
    _rows: M;
    _cols: N;
}
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const from2dVectors: <M, N, A>(ks: V.Vec<M, V.Vec<N, A>>) => Mat<M, N, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromNestedTuples: {
    <A>(t: []): Mat<0, 0, A>;
    <A>(t: [[A]]): Mat<1, 1, A>;
    <A>(t: [[A, A]]): Mat<1, 2, A>;
    <A>(t: [[A], [A]]): Mat<2, 1, A>;
    <A>(t: [[A, A], [A, A]]): Mat<2, 2, A>;
    <A>(t: [[A, A, A]]): Mat<1, 3, A>;
    <A>(t: [[A], [A], [A]]): Mat<3, 1, A>;
    <A>(t: [[A, A, A], [A, A, A]]): Mat<2, 3, A>;
    <A>(t: [[A, A], [A, A], [A, A]]): Mat<3, 2, A>;
    <A>(t: [[A, A, A], [A, A, A], [A, A, A]]): Mat<3, 3, A>;
    <A>(t: [[A, A, A, A]]): Mat<1, 4, A>;
    <A>(t: [[A], [A], [A], [A]]): Mat<4, 1, A>;
    <A>(t: [[A, A, A, A], [A, A, A, A]]): Mat<2, 4, A>;
    <A>(t: [[A, A], [A, A], [A, A], [A, A]]): Mat<4, 2, A>;
    <A>(t: [[A, A, A, A], [A, A, A, A], [A, A, A, A]]): Mat<3, 4, A>;
    <A>(t: [[A, A, A], [A, A, A], [A, A, A], [A, A, A]]): Mat<4, 3, A>;
    <A>(t: [[A, A, A, A], [A, A, A, A], [A, A, A, A], [A, A, A, A]]): Mat<4, 4, A>;
    <A>(t: [[A, A, A, A, A]]): Mat<1, 5, A>;
    <A>(t: [[A], [A], [A], [A], [A]]): Mat<5, 1, A>;
    <A>(t: [[A, A, A, A, A], [A, A, A, A, A]]): Mat<2, 5, A>;
    <A>(t: [[A, A], [A, A], [A, A], [A, A], [A, A]]): Mat<5, 2, A>;
    <A>(t: [[A, A, A, A, A], [A, A, A, A, A], [A, A, A, A, A]]): Mat<3, 5, A>;
    <A>(t: [[A, A, A], [A, A, A], [A, A, A], [A, A, A], [A, A, A]]): Mat<5, 3, A>;
    <A>(t: [[A, A, A, A, A], [A, A, A, A, A], [A, A, A, A, A], [A, A, A, A, A]]): Mat<4, 5, A>;
    <A>(t: [[A, A, A, A], [A, A, A, A], [A, A, A, A], [A, A, A, A], [A, A, A, A]]): Mat<5, 4, A>;
    <A>(t: [
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ]
    ]): Mat<5, 5, A>;
    <A>(t: [[A, A, A, A, A, A]]): Mat<1, 6, A>;
    <A>(t: [[A], [A], [A], [A], [A], [A]]): Mat<6, 1, A>;
    <A>(t: [[A, A, A, A, A, A], [A, A, A, A, A, A]]): Mat<2, 6, A>;
    <A>(t: [[A, A], [A, A], [A, A], [A, A], [A, A], [A, A]]): Mat<6, 2, A>;
    <A>(t: [[A, A, A, A, A, A], [A, A, A, A, A, A], [A, A, A, A, A, A]]): Mat<3, 6, A>;
    <A>(t: [[A, A, A], [A, A, A], [A, A, A], [A, A, A], [A, A, A], [A, A, A]]): Mat<6, 3, A>;
    <A>(t: [[A, A, A, A, A, A], [A, A, A, A, A, A], [A, A, A, A, A, A], [A, A, A, A, A, A]]): Mat<4, 6, A>;
    <A>(t: [
        [
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A
        ]
    ]): Mat<6, 4, A>;
    <A>(t: [
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ]
    ]): Mat<5, 6, A>;
    <A>(t: [
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A
        ]
    ]): Mat<6, 5, A>;
    <A>(t: [
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ],
        [
            A,
            A,
            A,
            A,
            A,
            A
        ]
    ]): Mat<6, 6, A>;
};
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromNestedReadonlyArrays: <M extends number, N extends number>(m: M, n: N) => <A>(as: ReadonlyArray<ReadonlyArray<A>>) => O.Option<Mat<M, N, A>>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromVectorAsRow: <N, A>(v: V.Vec<N, A>) => Mat<1, N, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromVectorAsColumn: <N, A>(v: V.Vec<N, A>) => Mat<N, 1, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const makeBy: <M extends number, N extends number, A>(m: M, n: N, f: (a: [number, number]) => A) => Mat<M, N, A>;
/**
 * Constructs the identity matrix
 *
 * @since 1.0.0
 * @category Constructors
 */
export declare const identity: <A>(R: Rng.Ring<A>) => <M extends number>(m: M) => Mat<M, M, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const repeat: <A>(a: A) => <M extends number, N extends number>(m: M, n: N) => Mat<M, N, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const randMatrix: <M extends number, N extends number, A>(m: M, n: N, make: IO.IO<A>) => IO.IO<Mat<M, N, A>>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const outerProduct: <A>(R: Rng.Ring<A>) => <M extends number, N extends number>(v1: V.Vec<M, A>, v2: V.Vec<N, A>) => Mat<M, N, A>;
/**
 * Constructs a Vandermonde matrix from a vector. Note: Terms is inclusive of the first
 * column of ones. So a quadratic Vandermonde matrix has 3 terms.
 *
 * @since 1.1.0
 * @category Constructors
 */
export declare const vand: <N extends number>(terms: N) => <M extends number>(t: V.Vec<M, number>) => Mat<M, N, number>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const URI = "Mat";
/**
 * @since 1.0.0
 * @category Instances
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind3<R, E, A> {
        readonly [URI]: Mat<R, E, A>;
    }
    interface URItoKind2<E, A> {
        readonly [URI]: Mat<E, E, A>;
    }
}
/**
 * @since 1.1.0
 * @category Instances
 */
export declare const getSquareMonoidProduct: <A>(R: Rng.Ring<A>) => <M extends number>(m: M) => Mn.Monoid<Mat<M, M, A>>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getAdditiveAbelianGroup: <A>(R: Rng.Ring<A>) => <M extends number, N extends number>(m: M, n: N) => TC.AbelianGroup<Mat<M, N, A>>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getBimodule: <A>(R: Rng.Ring<A>) => <M extends number, N extends number>(m: M, n: N) => TC.Bimodule<Mat<M, N, A>, A>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const map: <M, N, A, B>(f: (a: A) => B) => (v: Mat<M, N, A>) => Mat<M, N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Functor: Fun.Functor3<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const mapWithIndex: <M, N, A, B>(f: (ij: [number, number], a: A) => B) => (v: Mat<M, N, A>) => Mat<M, N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const FunctorWithIndex: FunI.FunctorWithIndex3<URI, [number, number]>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduce: <M, N, A, B>(b: B, f: (b: B, a: A) => B) => (fa: Mat<M, N, A>) => B;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const foldMap: <M>(M: Mn.Monoid<M>) => <N, O, A>(f: (a: A) => M) => (fa: Mat<N, O, A>) => M;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceRight: <M, N, B, A>(b: A, f: (b: B, a: A) => A) => (fa: Mat<M, N, B>) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Foldable: Fl.Foldable3<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceWithIndex: <M, N, A, B>(b: B, f: (i: [number, number], b: B, a: A) => B) => (fa: Mat<M, N, A>) => B;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const foldMapWithIndex: <M>(M: Mn.Monoid<M>) => <N, O, A>(f: (i: [number, number], a: A) => M) => (fa: Mat<N, O, A>) => M;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceRightWithIndex: <M, N, B, A>(b: A, f: (i: [number, number], b: B, a: A) => A) => (fa: Mat<M, N, B>) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const FoldableWithIndex: FlI.FoldableWithIndex3<URI, [number, number]>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare function sequence<F extends URIS4>(F: Apl.Applicative4<F>): <S, R, E, A, M, N>(ta: Mat<M, N, Kind4<F, S, R, E, A>>) => Kind4<F, S, R, E, Mat<M, N, A>>;
export declare function sequence<F extends URIS3>(F: Apl.Applicative3<F>): <R, E, A, M, N>(ta: Mat<M, N, Kind3<F, R, E, A>>) => Kind3<F, R, E, Mat<M, N, A>>;
export declare function sequence<F extends URIS2>(F: Apl.Applicative2<F>): <E, A, M, N>(ta: Mat<M, N, Kind2<F, E, A>>) => Kind2<F, E, Mat<M, N, A>>;
export declare function sequence<F extends URIS>(F: Apl.Applicative1<F>): <A, M, N>(ta: Mat<M, N, Kind<F, A>>) => Kind<F, Mat<M, N, A>>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare function traverse<F extends URIS4>(F: Apl.Applicative4<F>): <S, R, E, A, B>(f: (a: A) => Kind4<F, S, R, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind4<F, S, R, E, Mat<M, N, B>>;
export declare function traverse<F extends URIS3>(F: Apl.Applicative3<F>): <R, E, A, B>(f: (a: A) => Kind3<F, R, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind3<F, R, E, Mat<M, N, B>>;
export declare function traverse<F extends URIS2>(F: Apl.Applicative2<F>): <E, A, B>(f: (a: A) => Kind2<F, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind2<F, E, Mat<M, N, B>>;
export declare function traverse<F extends URIS>(F: Apl.Applicative1<F>): <A, B>(f: (a: A) => Kind<F, B>) => <M, N>(ta: Mat<M, N, A>) => Kind<F, Mat<M, N, B>>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare function traverseWithIndex<F extends URIS4>(F: Apl.Applicative4<F>): <S, R, E, A, B>(f: (i: [number, number], a: A) => Kind4<F, S, R, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind4<F, S, R, E, Mat<M, N, B>>;
export declare function traverseWithIndex<F extends URIS3>(F: Apl.Applicative3<F>): <R, E, A, B>(f: (i: [number, number], a: A) => Kind3<F, R, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind3<F, R, E, Mat<M, N, B>>;
export declare function traverseWithIndex<F extends URIS2>(F: Apl.Applicative2<F>): <E, A, B>(f: (i: [number, number], a: A) => Kind2<F, E, B>) => <M, N>(ta: Mat<M, N, A>) => Kind2<F, E, Mat<M, N, B>>;
export declare function traverseWithIndex<F extends URIS>(F: Apl.Applicative1<F>): <A, B>(f: (i: [number, number], a: A) => Kind<F, B>) => <M, N>(ta: Mat<M, N, A>) => Kind<F, Mat<M, N, B>>;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const toNestedReadonlyArrays: <M, N, A>(m: Mat<M, N, A>) => ReadonlyArray<ReadonlyArray<A>>;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const toNestedArrays: <M, N, A>(m: Mat<M, N, A>) => Array<Array<A>>;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const shape: <M extends number, N extends number, A>(m: Mat<M, N, A>) => [M, N];
/**
 * Map a particular row of a matrix
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const mapRow: <A>(rowIndex: number, f: (a: A) => A) => <M extends number, N extends number>(m: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * Reduce the rows of a matrix to a vector of opposite length
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const reduceByRow: <N extends number, A, B>(f: (a: V.Vec<N, A>) => B) => <M extends number>(m: Mat<M, N, A>) => V.Vec<M, B>;
/**
 * Map a particular column of a matrix
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const mapColumn: <A>(columnIndex: number, f: (a: A) => A) => <M extends number, N extends number>(m: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * Reduce the columns of a matrix to a vector of opposite length
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const reduceByColumn: <M extends number, A, B>(f: (a: V.Vec<M, A>) => B) => <N extends number>(A: Mat<M, N, A>) => V.Vec<N, B>;
/**
 * Used to extract a sub-column from a matrix, and returns a new generic `P` that
 * represents the length of the sub-column.
 *
 * Note: `fromIncl` is the **inclusive** column start-index, and `toExcl` is the
 * **exclusive** column end-index. If `toExcl` is omitted, then the extracted sub-column
 * will span to the last row of the matrix.
 *
 * Note: In order to preserve type safety, P cannot be inferred, and must be passed
 * directly as a type argument.
 *
 * If `P` is unknown, it can be declared in the parent function as an arbitrary generic
 * that has a numeric constraint.
 *
 * See: Decomposition > QR as an example declaring an unknown length constraint
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const getSubColumn: (col: number, fromIncl: number, toExcl?: number) => <P extends number, M extends number, N extends number, A>(m: Mat<M, N, A>) => O.Option<V.Vec<P, A>>;
/**
 * Used to replace a sub-column of a matrix along with a generic `P` that is the length of
 * the sub-column. If `P` is incompatible with matrix length `N`, or provided indices will
 * result in an overflow, `O.none` is returned.
 *
 * Note: `fromRowIncl` is the **inclusive** row start-index
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const updateSubColumn: <P extends number, A>(col: number, fromRowIncl: number, repl: V.Vec<P, A>) => <M extends number, N extends number>(m: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * Used to extract a portion of a matrix, and returns new generics `P` and `Q` that
 * represents the the rows / columns of the extracted sub-matrix.
 *
 * Note: `rowFromIncl` and `colFromIncl` are the **inclusive** row / column start-indices,
 * and `rowToExcl` and `colToExcl` are the **exclusive** row / column end-indices. If
 * `rowToExcl` or `colToExcl` are omitted, the extracted sub-matrix will span to the final
 * row / column.
 *
 * Note: In order to preserve type safety, `P` and `Q` cannot be inferred, and must be
 * passed directly as type arguments.
 *
 * If `P` and `Q` are unknown, they can be declared in the parent function as arbitrary
 * generics that have a numeric constraint.
 *
 * See: Decomposition > QR as an example declaring unknown length constraints
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const getSubMatrix: <P extends number, Q extends number>(rowFromIncl: number, colFromIncl: number, rowToExcl?: number, colToExcl?: number) => <M extends number, N extends number, A>(m: Mat<M, N, A>) => O.Option<Mat<P, Q, A>>;
/**
 * Used to replace a portion of a matrix with generics `P` and `Q` that are the rows /
 * columns of the replacement sub-matrix. If `P` is incompatible with matrix rows `M`, `Q`
 * is incompatible with matrix columns `N`, or if provided indices will result in an
 * overflow, `O.none` is returned.
 *
 * Note: `rowFromIncl` and `colFromIncl` are the **inclusive** row / column start-indices
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const updateSubMatrix: <P extends number, Q extends number, A>(rowFromIncl: number, colFromIncl: number, repl: Mat<P, Q, A>) => <M extends number, N extends number>(m: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * Add a column at the beginning of a matrix. Due to the limitations of the typesystem,
 * the length parameter must be passed explicitly, and will be the number of columns of
 * the returned matrix.
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const prependColumn: <M extends number, A>(c0: V.Vec<M, A>) => <P extends number, N extends number>(m: Mat<M, N, A>) => Mat<M, P, A>;
/**
 * Add a column at the end of a matrix. Due to the limitations of the typesystem, the
 * length parameter must be passed explicitly, and will be the number of columns of the
 * returned matrix.
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const appendColumn: <M extends number, A>(c0: V.Vec<M, A>) => <P extends number, N extends number>(m: Mat<M, N, A>) => Mat<M, P, A>;
/**
 * Crops a matrix to be square by removing excess rows. Returns O.none if there are more
 * columns than rows.
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const cropRows: <M extends number, N extends number, A>(m: Mat<M, N, A>) => O.Option<Mat<N, N, A>>;
/**
 * Crops a matrix to be square by removing excess columns. Returns O.none if there are
 * more columns than rows.
 *
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const cropColumns: <M extends number, N extends number, A>(m: Mat<M, N, A>) => O.Option<Mat<M, M, A>>;
/**
 * @since 1.0.0
 * @category Sub-Matrix
 */
export declare const switchRows: (i: number, j: number) => <A, N, M>(vs: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * @since 1.1.0
 * @category Sub-Matrix
 */
export declare const switchColumns: (i: number, j: number) => <N extends number, M extends number, A>(vs: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * Multiply two matricies with matching inner dimensions
 *
 * ```math
 * (A ∈ R_mn) (B ∈ R_np) = C ∈ R_mp
 * ```
 *
 * Efficiency: `2mpn` flops (for numeric Ring)
 *
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const mul: <A>(R: Rng.Ring<A>) => <M extends number, N1 extends number, N2 extends N1, P extends number>(x: Mat<M, N1, A>, y: Mat<N2, P, A>) => Mat<M, P, A>;
/**
 * Transform a vector `x` into vector `b` by matrix `A`
 *
 * ```math
 * Ax = b
 * ```
 *
 * Efficiency: `2mn` flops (for numeric Ring)
 *
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const linMap: <R>(R: Rng.Ring<R>) => <M, N1, N2 extends N1>(A: Mat<M, N1, R>, x: V.Vec<N2, R>) => V.Vec<M, R>;
/**
 * Transform a row-vector `x` into vector `b` by matrix `A`
 *
 * ```math
 * xA = b
 * ```
 *
 * Efficiency: `2mn` flops (for numeric Ring)
 *
 * @since 1.1.0
 * @category Matrix Operations
 */
export declare const linMapR: <R>(R: Rng.Ring<R>) => <M extends number, N1 extends number, N2 extends N1>(x: V.Vec<N1, R>, A: Mat<N2, M, R>) => V.Vec<M, R>;
/**
 * The sum of the diagonal elements
 *
 * Efficiency: `m` flops (for numeric Ring)
 *
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const trace: <A>(R: Rng.Ring<A>) => <M extends number>(fa: Mat<M, M, A>) => A;
/**
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const transpose: <M extends number, N extends number, A>(v: Mat<M, N, A>) => Mat<N, M, A>;
/**
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const get: (i: number, j: number) => <M, N, A>(m: Mat<M, N, A>) => O.Option<A>;
/**
 * @since 1.1.0
 * @category Matrix Operations
 */
export declare const updateAt: <A>(i: number, j: number, a: A) => <M extends number, N extends number>(A: Mat<M, N, A>) => O.Option<Mat<M, N, A>>;
/**
 * @since 1.0.0
 * @category Matrix Operations
 */
export declare const lift2: <A, B>(f: (x: A, y: A) => B) => <M, N>(x: Mat<M, N, A>, y: Mat<M, N, A>) => Mat<M, N, B>;
//# sourceMappingURL=Matrix.d.ts.map