/**
 * A vector type constrained to a particular size enforced by the type system, and
 * associated typeclasses.
 *
 * @since 1.0.0
 */
import * as Fun from 'fp-ts/Functor';
import * as FunI from 'fp-ts/FunctorWithIndex';
import * as Ap from 'fp-ts/Apply';
import * as Apl from 'fp-ts/Applicative';
import * as Bnd from 'fp-ts/Bounded';
import * as Chn from 'fp-ts/Chain';
import * as Fl from 'fp-ts/Foldable';
import * as FlI from 'fp-ts/FoldableWithIndex';
import * as Fld from 'fp-ts/Field';
import * as IO from 'fp-ts/IO';
import { HKT } from 'fp-ts/HKT';
import * as Mon from 'fp-ts/Monad';
import * as Mn from 'fp-ts/Monoid';
import * as O from 'fp-ts/Option';
import * as Tr from 'fp-ts/Traversable';
import * as TrI from 'fp-ts/TraversableWithIndex';
import * as Pt from 'fp-ts/Pointed';
import * as Rng from 'fp-ts/Ring';
import * as TC from './typeclasses';
import { Complex } from './complex';
/**
 * @since 1.0.0
 * @category Model
 */
export interface Vec<N, A> extends ReadonlyArray<A> {
    _length: N;
}
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromTuple: {
    <A>(t: []): Vec<0, A>;
    <A>(t: [A]): Vec<1, A>;
    <A>(t: [A, A]): Vec<2, A>;
    <A>(t: [A, A, A]): Vec<3, A>;
    <A>(t: [A, A, A, A]): Vec<4, A>;
    <A>(t: [A, A, A, A, A]): Vec<5, A>;
    <A>(t: [A, A, A, A, A, A]): Vec<6, A>;
    <A>(t: [A, A, A, A, A, A, A]): Vec<7, A>;
    <A>(t: [A, A, A, A, A, A, A, A]): Vec<8, A>;
    <A>(t: [A, A, A, A, A, A, A, A, A]): Vec<9, A>;
    <A>(t: [A, A, A, A, A, A, A, A, A, A]): Vec<10, A>;
};
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const fromReadonlyArray: <N extends number>(n: N) => <A>(as: ReadonlyArray<A>) => O.Option<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const makeBy: <N extends number, A>(n: N, make: (i: number) => A) => Vec<N, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const repeat: <N extends number, A>(n: N, a: A) => Vec<N, A>;
/**
 * @since 1.0.0
 * @category Constructors
 */
export declare const randVec: <N extends number, A>(n: N, make: IO.IO<A>) => IO.IO<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const URI = "Vec";
/**
 * @since 1.0.0
 * @category Instances
 */
export declare type URI = typeof URI;
declare module 'fp-ts/HKT' {
    interface URItoKind2<E, A> {
        readonly [URI]: Vec<E, A>;
    }
}
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getAdditiveAbelianGroup: <A>(R: Rng.Ring<A>) => <N extends number>(n: N) => TC.AbelianGroup<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const getBimodule: <R>(R: Rng.Ring<R>) => <N extends number>(n: N) => TC.Bimodule<Vec<N, R>, R>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const map: <N, A, B>(f: (a: A) => B) => (v: Vec<N, A>) => Vec<N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Functor: Fun.Functor2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const mapWithIndex: <N, A, B>(f: (i: number, a: A) => B) => (v: Vec<N, A>) => Vec<N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const FunctorWithIndex: FunI.FunctorWithIndex2<URI, number>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const of: <A>(a: A) => Vec<1, A>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Pointed: Pt.Pointed2C<URI, 1>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const ap: <N, A, B>(fa: Vec<N, A>) => (fab: Vec<N, (a: A) => B>) => Vec<N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Apply: Ap.Apply2<URI>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const apFirst: <E, B>(second: Vec<E, B>) => <A>(first: Vec<E, A>) => Vec<E, A>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const apSecond: <E, B>(second: Vec<E, B>) => <A>(first: Vec<E, A>) => Vec<E, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Applicative: Apl.Applicative2C<URI, 1>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const chain: <A, B>(f: (a: A) => Vec<1, B>) => <N>(ma: Vec<N, A>) => Vec<N, B>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Chain: Chn.Chain2C<URI, 1>;
/**
 * @since 1.0.0
 * @category Combinators
 */
export declare const chainFirst: <A, B>(f: (a: A) => Vec<1, B>) => (first: Vec<1, A>) => Vec<1, A>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Monad: Mon.Monad2C<URI, 1>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduce: <N, A, B>(b: B, f: (b: B, a: A) => B) => (fa: Vec<N, A>) => B;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const foldMap: <M>(M: Mn.Monoid<M>) => <N, A>(f: (a: A) => M) => (fa: Vec<N, A>) => M;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceRight: <N, B, A>(b: A, f: (b: B, a: A) => A) => (fa: Vec<N, B>) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Foldable: Fl.Foldable2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceWithIndex: <N, A, B>(b: B, f: (i: number, b: B, a: A) => B) => (fa: Vec<N, A>) => B;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const foldMapWithIndex: <M>(M: Mn.Monoid<M>) => <N, A>(f: (i: number, a: A) => M) => (fa: Vec<N, A>) => M;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const reduceRightWithIndex: <N, B, A>(b: A, f: (i: number, b: B, a: A) => A) => (fa: Vec<N, B>) => A;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const FoldableWithIndex: FlI.FoldableWithIndex2<URI, number>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const traverse: Tr.PipeableTraverse2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const sequence: <F>(F: Apl.Applicative<F>) => <N, A>(fa: Vec<N, HKT<F, A>>) => HKT<F, Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const Traversable: Tr.Traversable2<URI>;
/**
 * @since 1.0.0
 * @category Instance Operations
 */
export declare const traverseWithIndex: TrI.PipeableTraverseWithIndex2<URI, number>;
/**
 * @since 1.0.0
 * @category Instances
 */
export declare const TraversableWithIndex: TrI.TraversableWithIndex2<URI, number>;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const toTuple: {
    <A>(t: Vec<0, A>): [];
    <A>(t: Vec<1, A>): [A];
    <A>(t: Vec<2, A>): [A, A];
    <A>(t: Vec<3, A>): [A, A, A];
    <A>(t: Vec<4, A>): [A, A, A, A];
    <A>(t: Vec<5, A>): [A, A, A, A, A];
    <A>(t: Vec<6, A>): [A, A, A, A, A, A];
    <A>(t: Vec<7, A>): [A, A, A, A, A, A, A];
    <A>(t: Vec<8, A>): [A, A, A, A, A, A, A, A];
    <A>(t: Vec<9, A>): [A, A, A, A, A, A, A, A, A];
    <A>(t: Vec<10, A>): [A, A, A, A, A, A, A, A, A, A];
};
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const size: <N extends number, A>(v: Vec<N, A>) => N;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const lpNorm: (p: number) => <A extends number | Complex>(R: Rng.Ring<A>, abs: (x: A) => A, pow: (x: A, n: number) => A) => <N>(x: Vec<N, A>) => A;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const l1Norm: <A extends number | Complex>(R: Rng.Ring<A>) => <N>(x: Vec<N, A>) => A;
/**
 * @since 1.0.0
 * @category Destructors
 */
export declare const l2Norm: <A extends number | Complex>(R: Rng.Ring<A>, abs: (x: A) => A, pow: (x: A, n: number) => A) => <N>(x: Vec<N, A>) => A;
/**
 * Get the maximum value of a vector
 *
 * @since 1.0.0
 * @category Destructors
 */
export declare const lInfNorm: <A>(B: Bnd.Bounded<A>, abs: (a: A) => A) => <N>(x: Vec<N, A>) => A;
/**
 * @since 1.1.0
 * @category Vector Operations
 */
export declare const switchIndices: (i: number, j: number) => <N extends number, A>(v: Vec<N, A>) => O.Option<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const lift2: <A, B>(f: (x: A, y: A) => B) => <N>(x: Vec<N, A>, y: Vec<N, A>) => Vec<N, B>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const mapIndex: (n: number) => <A>(f: (a: A) => A) => <N>(fa: Vec<N, A>) => O.Option<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const updateAt: (n: number) => <A>(a: A) => <N>(fa: Vec<N, A>) => O.Option<Vec<N, A>>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const zipVectors: <N, A, B>(v1: Vec<N, A>, v2: Vec<N, B>) => Vec<N, readonly [A, B]>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const reverse: <N, A>(v1: Vec<N, A>) => Vec<N, A>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const get: (i: number) => <N, A>(fa: Vec<N, A>) => O.Option<A>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const crossProduct: <A>(R: Rng.Ring<A>) => (x: Vec<3, A>, y: Vec<3, A>) => Vec<3, A>;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const innerProduct: <A extends number | Complex>(R: Rng.Ring<A>, conj: (r: A) => A) => <N>(x: Vec<N, A>, y: Vec<N, A>) => A;
/**
 * @since 1.0.0
 * @category Vector Operations
 */
export declare const projection: <R extends number | Complex>(F: Fld.Field<R>, conj: (r: R) => R) => <N extends number>(u: Vec<N, R>, v: Vec<N, R>) => Vec<N, R>;
/**
 * Add an element at the beginning of a vector. Due to the limitations of the typesystem,
 * the length parameter must be passed explicitly, and will be the new length of the
 * returned matrix.
 *
 * @since 1.1.0
 * @category Vector Operations
 */
export declare const prepend: <A>(head: A) => <P extends number, N extends number>(v: Vec<N, A>) => Vec<P, A>;
/**
 * Add an element at the end of a vector. Due to the limitations of the typesystem, the
 * length parameter must be passed explicitly, and will be the new length of the returned matrix.
 *
 * @since 1.1.0
 * @category Vector Operations
 */
export declare const append: <A>(head: A) => <P extends number, N extends number>(v: Vec<N, A>) => Vec<P, A>;
/**
 * @since 1.0.0
 * @category Do notation
 */
export declare const bindTo: <N extends string>(name: N) => <E, A>(fa: Vec<E, A>) => Vec<E, { readonly [K in N]: A; }>;
/**
 * @since 1.0.0
 * @category Do notation
 */
export declare const bind: <N extends string, A, B>(name: Exclude<N, keyof A>, f: (a: A) => Vec<1, B>) => (ma: Vec<1, A>) => Vec<1, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
/**
 * @since 1.0.0
 * @category Do notation
 */
export declare const apS: <N extends string, A, E, B>(name: Exclude<N, keyof A>, fb: Vec<E, B>) => (fa: Vec<E, A>) => Vec<E, { readonly [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
//# sourceMappingURL=Vector.d.ts.map