import { ops, scalar, scalarExt, has } from './core';
import complex from './complex';
import { PolynomialN } from './polynomial';
import { Blade } from './kvector';
export { Blade } from './kvector';
export declare const E2: readonly ["x", "y"];
export type E2 = typeof E2[number];
export declare const E3: readonly ["x", "y", "z"];
export type E3 = typeof E3[number];
export declare const E4: readonly ["x", "y", "z", "w"];
export type E4 = typeof E4[number];
export declare const E5: readonly ["x", "y", "z", "w", "c5"];
export type E5 = typeof E5[number];
export declare const E6: readonly ["x", "y", "z", "w", "c5", "c6"];
export type E6 = typeof E6[number];
export type vec<T, E extends string> = {
    [K in E]: T;
};
export declare function vec<T, E extends string>(e: readonly E[], ...v: T[]): vec<T, E>;
type vecKeys<V, T> = {
    [K in keyof V]: V[K] extends T ? K : never;
}[keyof V] & string;
type swiz2<T2, E extends string> = {
    [K in `${E}${E}`]: T2;
};
type swiz3<T3, T2, E extends string> = swiz2<T2, E> & {
    [K in `${E}${E}${E}`]: T3;
};
type swiz4<T4, T3, T2, E extends string> = swiz3<T3, T2, E> & {
    [K in `${E}${E}${E}${E}`]: T4;
};
export interface vops<C extends vops<C, S>, S = any> extends ops<C, S> {
    create(...args: S[]): C;
    _values: S[];
    dup(): C;
    abs(): C;
    min(b: C): C;
    max(b: C): C;
    eq(b: C): boolean;
    dot(b: C): S;
    perp(): C;
    lensq(): S;
    len(): S;
    mag(): number | scalarExt<any>;
    selfScale(b: S): void;
    selfMul(b: C): void;
    selfAdd(b: C): void;
    selfSub(b: C): void;
    clamp(min: C, max: C): C;
}
type scalarOf<C> = C extends vops<any, infer S> ? S : number;
export type vector<E extends string, S = number> = vec<S, E> & vops<vector<E, S>, S>;
export declare function vector<E extends string>(e: readonly E[], ...v: number[]): vector<E>;
export declare class vecImp<E extends string> implements vops<vector<E>, number> {
    constructor(v: vec<number, E>);
    private keys;
    private entries;
    private asVec;
    create(...args: number[]): vector<E>;
    get _values(): number[];
    dup(): vector<E, number>;
    neg(): vector<E, number>;
    abs(): vector<E, number>;
    scale(b: number): vector<E, number>;
    mul(b: vector<E>): vector<E, number>;
    div(b: vector<E>): vector<E, number>;
    add(b: vector<E>): vector<E, number>;
    sub(b: vector<E>): vector<E, number>;
    min(b: vector<E>): vector<E, number>;
    max(b: vector<E>): vector<E, number>;
    eq(b: vector<E>): boolean;
    dot(b: vector<E>): number;
    perp(): vector<E, number>;
    lensq(): number;
    len(): number;
    mag(): number;
    selfScale(b: number): void;
    selfMul(b: vector<E>): void;
    selfAdd(b: vector<E>): void;
    selfSub(b: vector<E>): void;
    clamp(min: vector<E>, max: vector<E>): vector<E, number>;
    cross(b: vector<E>): number | Blade<number> | vector<E, number>;
    toString(): string;
}
export type vscalar<C extends vscalar<C, S>, S = number> = scalar<C, S> & has<'sqrt'> & has<'recip'>;
export declare function vectorT<T extends vscalar<T>, E extends string>(e: readonly E[], ...v: T[]): vector<E, T>;
export declare class vecImpT<T extends vscalar<T>, E extends string> implements vops<vector<E, T>, T> {
    constructor(v: vec<T, E>);
    private keys;
    private entries;
    private asVec;
    create(...args: T[]): vector<E, T>;
    get _values(): T[];
    dup(): vector<E, T>;
    neg(): vector<E, T>;
    abs(): vector<E, T>;
    scale(b: T): vector<E, T>;
    mul(b: vector<E, T>): vector<E, T>;
    div(b: vector<E, T>): vector<E, T>;
    add(b: vector<E, T>): vector<E, T>;
    sub(b: vector<E, T>): vector<E, T>;
    min(b: vector<E, T>): vector<E, T>;
    max(b: vector<E, T>): vector<E, T>;
    eq(b: vector<E, T>): boolean;
    dot(b: vector<E, T>): T;
    perp(): vector<E, T>;
    lensq(): T;
    len(): any;
    mag(): any;
    selfScale(b: T): void;
    selfMul(b: vector<E, T>): void;
    selfAdd(b: vector<E, T>): void;
    selfSub(b: vector<E, T>): void;
    clamp(min: vector<E, T>, max: vector<E, T>): vector<E, T>;
    cross(b: vector<E, T>): T | vector<E, T> | Blade<T>;
    toString(): string;
}
export declare class floatN extends Array<number> implements vops<floatN, number> {
    constructor(...args: number[]);
    create(...args: number[]): floatN;
    get _values(): number[];
    static from<T extends Iterable<number> | ArrayLike<number>>(input: T, mapFn?: (v: number, i: number) => number, thisArg?: any): floatN;
    static zeros(n: number): floatN;
    static fromArray(v: number[]): floatN;
    static fromVec(v: vec<number, string>): floatN;
    dup(): floatN;
    neg(): floatN;
    abs(): floatN;
    scale(b: number): floatN;
    mul(b: floatN): floatN;
    div(b: floatN): floatN;
    add(b: floatN): floatN;
    sub(b: floatN): floatN;
    min(b: floatN): floatN;
    max(b: floatN): floatN;
    eq(b: floatN): boolean;
    dot(b: floatN): number;
    perp(): floatN;
    lensq(): number;
    len(): number;
    mag(): number;
    selfScale(b: number): void;
    selfMul(b: floatN): void;
    selfAdd(b: floatN): void;
    selfSub(b: floatN): void;
    clamp(min: floatN, max: floatN): floatN;
    toString(): string;
}
export type ColumnType<E extends string, S = any> = vops<ColumnType<E, S>, S> & vec<S, E>;
export interface matOps<C extends vops<C, any>, R extends string, S = scalarOf<C>> {
    create(...cols: C[]): this;
    columns(): C[];
    inverse(): this;
    det(): S;
    scale(s: S): mat<C, R>;
    add(b: mat<C, R>): mat<C, R>;
    mul(v: vec<S, R>): C;
    mul0(v: vec<S, string>, col: string): C;
    matmul<M2 extends vec<ColumnType<R>, any>>(m: M2): mat<C, vecKeys<M2, C>>;
    trace(): S;
    characteristic(): PolynomialN<number>;
    eigenvalues(): complex[];
}
export type mat<C extends vops<C, any>, R extends string> = matOps<C, R> & vec<C, R>;
export declare function eigenvalues(A: floatN[]): complex[];
export declare function matClass<C extends vops<C>, R extends string>(): new (cols: vec<C, R>) => mat<C, R>;
export declare function mat<C extends vops<C>, R extends string>(m: vec<C, R>): mat<C, R>;
export declare function matmul<C extends vops<C>, R extends string, M2 extends vec<ColumnType<R>, any>>(a: matOps<C, R>, b: M2): mat<C, vecKeys<M2, C>>;
export declare function matmulExt<C1 extends vops<C1>, R1 extends string, R2 extends string>(a: matOps<C1, R1>, b: vec<any, R2>): mat<C1, R1 | R2>;
export declare function mulExt<C extends vops<C>, R extends string>(a: matOps<C, R>, v: vec<any, string>): C;
declare class extentV<C extends vops<C>> {
    min: C;
    max: C;
    constructor(min: C, max: C);
    extent(): C;
    centre(): C;
    add(p: C): void;
    combine(b: extentV<C>): void;
    encompasses(b: extentV<C>): boolean;
    overlaps(b: extentV<C>): boolean;
    contains(p: C): boolean;
    clamp(p: C): C;
}
export declare function mid<C extends vops<C>>(a: C, b: C): C;
export declare function normalise<T extends has<'recip'> | number, C extends vops<C, T>>(a: C): C;
export declare function project<C extends vops<C>>(a: C, b: C): C;
export declare function reflect<C extends vops<C>>(a: C, b: C): C;
export declare function lerp<C extends vops<C>>(a: C, b: C, t: number): C;
export declare function approx_equal<C extends vops<C>>(a: C, b: C, tol?: number): boolean;
export declare function safeNormalise<C extends vops<C>>(a: C): C | undefined;
export interface float2 extends vec<number, E2>, swiz2<float2, E2>, vops<float2> {
    cross(b: float2): number;
    atan2(): number;
}
declare class extent2 extends extentV<float2> {
    static fromCentreExtent(centre: float2, size: float2): extent2;
    static from<U extends Iterable<float2>>(items: U): extent2;
    constructor(min?: float2, max?: float2);
    overlaps(b: extentV<float2>): boolean;
    encompasses(b: extent2): boolean;
    contains(b: float2): boolean;
}
export declare const float2: ((x: number, y: number) => float2) & {
    zero(): float2;
    cossin(angle: number): float2;
    translate(z: float2): float2x3;
    scale(s: {
        x: number;
        y: number;
    } | number): float2x2;
    rotate(t: number): float2x2;
    extent: typeof extent2;
};
export declare namespace float2 {
    type extent = extent2;
}
export declare function sincos_half(sc: float2): float2;
export declare function max_circle_point(m: float2x2): float2;
export type float2x2 = mat<float2, E2> & {
    mulPos(v: float2): float2;
};
export declare const float2x2: ((x: float2, y: float2) => float2x2) & {
    identity(): float2x2;
};
export type float2x3 = mat<float2, E3> & {
    mulPos(v: float2): float2;
    mulAffine(this: float2x3, b: float2x3 | float2x2): float2x3;
};
export declare const float2x3: ((x: float2, y: float2, z: float2) => float2x3) & {
    identity(): float2x3;
};
export interface float3 extends vec<number, E3>, swiz3<float3, float2, E3>, vops<float3> {
    cross(b: float3): float3;
    perpUnit(): float3;
}
export declare const float3: ((x: number, y: number, z: number) => float3) & {
    zero(): float3;
    translate(w: float3): float3x4;
    scale(s: vec<number, E3> | number): float3x3;
    extent: {
        new (min?: float3, max?: float3): {
            min: float3;
            max: float3;
            extent(): float3;
            centre(): float3;
            add(p: float3): void;
            combine(b: extentV<float3>): void;
            encompasses(b: extentV<float3>): boolean;
            overlaps(b: extentV<float3>): boolean;
            contains(p: float3): boolean;
            clamp(p: float3): float3;
        };
    };
};
export declare namespace float3 {
    type extent = typeof float3.extent;
}
export type float3x3 = mat<float3, E3>;
export declare const float3x3: ((x: float3, y: float3, z: float3) => float3x3) & {
    identity(): float3x3;
    basis(dir: float3): float3x3;
};
export type float3x4 = mat<float3, E4> & {
    mulPos(v: float3): float3;
    mulAffine(this: float3x4, b: float3x4 | float3x3): float3x4;
};
export declare const float3x4: ((x: float3, y: float3, z: float3, w: float3) => float3x4) & {
    identity(): float3x4;
};
export interface float4 extends vec<number, E4>, swiz4<float4, float3, float2, E4>, vops<float4> {
}
export declare const float4: ((x: number, y: number, z: number, w: number) => float4) & {
    zero(): float4;
    scale(s: vec<number, E4> | number): float4x4;
    extent: {
        new (min?: float4, max?: float4): {
            min: float4;
            max: float4;
            extent(): float4;
            centre(): float4;
            add(p: float4): void;
            combine(b: extentV<float4>): void;
            encompasses(b: extentV<float4>): boolean;
            overlaps(b: extentV<float4>): boolean;
            contains(p: float4): boolean;
            clamp(p: float4): float4;
        };
    };
};
export declare namespace float4 {
    type extent = typeof float4.extent;
}
export type float4x4 = mat<float4, E4>;
export declare const float4x4: ((x: float4, y: float4, z: float4, w: float4) => float4x4) & {
    identity(): float4x4;
    basis(v: float4): float4x4;
};