import type { LatticeParams, Pbc } from './structure/index';
export type Vec2 = [number, number];
export type Vec3 = [number, number, number];
export type Vec4 = [number, number, number, number];
export type Point2D = {
    x: number;
    y: number;
};
export type Point3D = Point2D & {
    z: number;
};
export type Matrix3x3 = [Vec3, Vec3, Vec3];
export declare const is_finite_vec3_like: (values: unknown) => values is ArrayLike<number>;
export declare const finite_vec3_from_values: (values: unknown) => Vec3 | undefined;
export type Matrix4Tuple = [
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number,
    number
];
export declare function combinations<T>(arr: T[], k: number): T[][];
export declare const LOG_EPS = 1e-9;
export declare const EPS = 1e-10;
export declare const DEG_TO_RAD: number;
export declare const to_degrees: (radians: number) => number;
export declare const to_radians: (degrees: number) => number;
export declare const clamp: (value: number, lo: number, hi: number) => number;
export declare const partition_point: <Value>(values: readonly Value[], comes_before: (value: Value) => boolean) => number;
export declare const first_non_increasing_index: (values: ArrayLike<number>) => number | null;
export declare function calc_lattice_params(matrix: Matrix3x3): LatticeParams & {
    volume: number;
};
export declare const scale: <T extends number[]>(vec: T, factor: number) => T;
export declare function euclidean_dist(vec1: readonly number[], vec2: readonly number[]): number;
export declare const min_image_displacement: (from: Vec3, to: Vec3, lattice_matrix: Matrix3x3, converters?: LatticeConverters, pbc?: Pbc) => Vec3;
export declare function min_image_displacement_into(from: Vec3, to: Vec3, lattice_matrix: Matrix3x3, converters: LatticeConverters | undefined, pbc: Pbc, out: Vec3): Vec3;
export declare const pbc_dist: (pos1: Vec3, pos2: Vec3, lattice_matrix: Matrix3x3, converters?: LatticeConverters, pbc?: Pbc) => number;
export declare function det_3x3(matrix: Matrix3x3): number;
export declare function matrix_inverse_3x3(matrix: Matrix3x3): Matrix3x3;
export declare function mat3x3_vec3_multiply(matrix: Matrix3x3, vector: Vec3): Vec3;
export declare function add<T extends number[]>(...vecs: T[]): T;
export declare function subtract<T extends number[]>(vec1: T, vec2: T): T;
export declare function dot(vec1: Matrix3x3, vec2: Matrix3x3): Matrix3x3;
export declare function dot(vec1: Matrix3x3, vec2: Vec3): Vec3;
export declare function dot(vec1: readonly number[], vec2: readonly number[]): number;
export declare function dot(vec1: number[][], vec2: readonly number[]): number[];
export declare function dot(vec1: number[][], vec2: number[][]): number[][];
export declare function vec9_to_mat3x3(flat_array: number[]): Matrix3x3;
export declare const transpose_3x3_matrix: (matrix: Matrix3x3) => Matrix3x3;
export declare const scale_lattice_matrix: (orig_matrix: Matrix3x3, scaling_factors: Vec3) => Matrix3x3;
export declare function reciprocal_lattice(lattice: Matrix3x3, options?: {
    two_pi?: boolean;
}): Matrix3x3;
export declare const create_frac_to_cart: (lattice: Matrix3x3) => (frac: Vec3) => Vec3;
export declare const create_cart_to_frac: (lattice: Matrix3x3) => (cart: Vec3) => Vec3;
export type LatticeConverters = {
    lattice: Matrix3x3;
    reciprocal: Matrix3x3;
    reciprocal_axis_norms: Vec3;
    cart_to_frac: (cart: Vec3) => Vec3;
    frac_to_cart: (frac: Vec3) => Vec3;
};
export declare const create_lattice_converters: (lattice: Matrix3x3) => LatticeConverters;
export declare function cell_to_lattice_matrix(a: number, b: number, c: number, alpha: number, beta: number, gamma: number): Matrix3x3;
export declare function gcd(val_a: number, val_b: number): number;
export declare const gcd_all: (values: number[]) => number;
export declare function reduce_miller_indices(hkl: Vec3): Vec3;
export declare function mean(values: readonly number[]): number;
export declare function sample_std(values: readonly number[]): number;
export declare function median(values: readonly number[]): number;
export declare function get_coefficient_of_variation(values: number[]): number;
export declare function det_nxn(matrix: number[][]): number;
export declare const cross_3d: (vec1: ArrayLike<number>, vec2: ArrayLike<number>) => Vec3;
export declare function cell_heights(matrix: Matrix3x3): Vec3;
export declare const frac_cutoff_per_axis: (matrix: Matrix3x3, dist: number) => Vec3;
export declare const lerp: (start: number, end: number, t: number) => number;
export declare const lerp_vec3: (start: Vec3, end: Vec3, t: number) => Vec3;
type Normalized<T extends readonly number[]> = {
    -readonly [K in keyof T]: number;
};
export declare function normalize_vec<T extends readonly number[]>(vec: T, fallback?: NoInfer<T>): Normalized<T>;
export declare function compute_in_plane_basis(normal: Vec3): [Vec3, Vec3];
export declare function merge_coplanar_triangles(positions: Float32Array, tolerance?: number): Float32Array;
export declare function is_square_matrix(matrix: unknown, dim: number): matrix is number[][];
export declare function point_in_polygon(point_x: number, point_y: number, vertices: Vec2[]): boolean;
export declare function compute_bounding_box_2d(vertices: Vec2[]): {
    min: Vec2;
    max: Vec2;
    width: number;
    height: number;
};
export declare function polygon_centroid(vertices: Vec2[]): Vec2;
export declare function solve_linear_system(coefficients: number[][], // NxN coefficient matrix
rhs: number[]): number[] | null;
export declare function convex_hull_2d(points: Vec2[], tolerance?: number): Vec2[];
export declare const array_min: (values: readonly number[]) => number;
export declare const array_max: (values: readonly number[]) => number;
export declare function array_extent(values: readonly number[]): Vec2;
export declare function quickselect(values: number[], kth: number): number;
export declare function quantile_unordered(values: number[], p: number): number;
export type LinearProgramStatus = `optimal` | `infeasible` | `unbounded`;
export interface LinearProgramResult {
    status: LinearProgramStatus;
    solution: number[];
    objective: number;
}
export declare function solve_linear_program(objective: number[], // c, one entry per column
constraints: number[][], // A, one row per equality constraint
rhs: number[], // b, one entry per row
tolerance?: number): LinearProgramResult;
export {};