#vlab — 向量空間與有限維內積空間之組合式演算法庫（MoonBit）

pub struct AlgoEntry {
  id : String
  name : String
  check : () -> Bool
}

pub struct C {
  re : Double
  im : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct CMat {
  rows : Int
  cols : Int
  data : Array[C]
}

pub struct DualVec {
  coef : Array[Double]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct ExtVec {
  n : Int
  k : Int
  data : Array[Double]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct HVec {
  comps : Array[Quat]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct IPSp[V] {
  sp : VecSp[V]
  inner : (V, V) -> Double
}

pub struct MPoly {
  nvars : Int
  terms : Array[(Array[Int], Double)]
}

pub struct Mat {
  rows : Int
  cols : Int
  data : Array[Double]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Quat {
  w : Double
  x : Double
  y : Double
  z : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct Tensor {
  m : Int
  n : Int
  data : Array[Double]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub struct VecSp[V] {
  zero : V
  add : (V, V) -> V
  neg : (V) -> V
  scale : (Double, V) -> V
}

fn cabs(a : C) -> Double

fn cadd(a : C, b : C) -> C

fn carg(a : C) -> Double

fn cconj(a : C) -> C

fn cdiv(a : C, b : C) -> C

fn ceq_eps(a : C, b : C, eps : Double) -> Bool

fn cexp(a : C) -> C

fn cfrom_real(x : Double) -> C

fn ci() -> C

fn cinv(a : C) -> C

fn cmat_dagger(m : CMat) -> CMat

fn cmat_get(m : CMat, i : Int, j : Int) -> C

fn cmat_is_hermitian(m : CMat, eps : Double) -> Bool

fn cmat_jacobi_hermitian(m : CMat, max_sweeps : Int) -> (Array[Double], CMat)

fn cmat_mul(a : CMat, b : CMat) -> CMat

fn cmat_new(rows : Int, cols : Int) -> CMat

fn cmat_rayleigh(m : CMat, x : Array[C]) -> Double

fn cmat_set(m : CMat, i : Int, j : Int, v : C) -> Unit

fn cmat_unitary_error(q : CMat) -> Double

fn cmat_vec(m : CMat, x : Array[C]) -> Array[C]

fn cmul(a : C, b : C) -> C

fn cneg(a : C) -> C

fn cnew(re : Double, im : Double) -> C

fn cnorm2(a : C) -> Double

fn comb_count(n : Int, k : Int) -> Int

fn comb_index(combs : Array[Array[Int]], c : Array[Int]) -> Int

fn comb_list(n : Int, k : Int) -> Array[Array[Int]]

fn cone() -> C

fn cpolar(r : Double, theta : Double) -> C

fn cscale(s : Double, a : C) -> C

fn csqr(a : C) -> C

fn csqrt(a : C) -> C

fn cstr(a : C) -> String

fn csub(a : C, b : C) -> C

fn cvec_add(a : Array[C], b : Array[C]) -> Array[C]

fn cvec_cscale(c : C, a : Array[C]) -> Array[C]

fn cvec_inner(a : Array[C], b : Array[C]) -> C

fn cvec_is_orthogonal(a : Array[C], b : Array[C], eps : Double) -> Bool

fn cvec_neg(a : Array[C]) -> Array[C]

fn cvec_norm(v : Array[C]) -> Double

fn cvec_norm2(v : Array[C]) -> Double

fn cvec_orthonormal(vs : Array[Array[C]], eps : Double) -> Array[Array[C]]

fn cvec_real_ip(n : Int) -> IPSp[Array[C]]

fn cvec_scale(s : Double, a : Array[C]) -> Array[C]

fn cvec_zero(n : Int) -> Array[C]

fn czero() -> C

fn diag_add(a : Array[Double], b : Array[Double]) -> Array[Double]

fn diag_apply(a : Array[Double], x : Array[Double]) -> Array[Double]

fn diag_det(a : Array[Double]) -> Double

fn diag_dim(n : Int) -> Int

fn[V] diag_embed(v : V) -> (V, V)

fn diag_inner(a : Array[Double], b : Array[Double]) -> Double

fn diag_inv(a : Array[Double]) -> Array[Double]?

fn diag_ip(n : Int) -> IPSp[Array[Double]]

fn diag_mul(a : Array[Double], b : Array[Double]) -> Array[Double]

fn diag_scale(c : Double, a : Array[Double]) -> Array[Double]

fn diag_spectral_radius(a : Array[Double]) -> Double

fn diag_to_mat(a : Array[Double]) -> Mat

fn diag_trace(a : Array[Double]) -> Double

fn double_dual_action(v : Array[Double], phis : Array[DualVec]) -> Array[Double]

fn dual_action(phi : DualVec, v : Array[Double]) -> Double

fn dual_add(a : DualVec, b : DualVec) -> DualVec

fn dual_basis(n : Int) -> Array[DualVec]

fn dual_in_annihilator(phi : DualVec, span_gen : Array[Array[Double]], eps : Double) -> Bool

fn dual_inner(a : DualVec, b : DualVec) -> Double

fn dual_ip(n : Int) -> IPSp[DualVec]

fn dual_map(a : Mat) -> Mat

fn dual_pairing_matrix(phis : Array[DualVec], n : Int) -> Mat

fn dual_scale(c : Double, phi : DualVec) -> DualVec

fn dual_zero(n : Int) -> DualVec

fn euc_add(a : Array[Double], b : Array[Double]) -> Array[Double]

fn euc_basis(n : Int) -> Array[Array[Double]]

fn euc_cross3(a : Array[Double], b : Array[Double]) -> Array[Double]

fn euc_eq_eps(a : Array[Double], b : Array[Double], eps : Double) -> Bool

fn euc_hadamard(a : Array[Double], b : Array[Double]) -> Array[Double]

fn euc_inf_norm(a : Array[Double]) -> Double

fn euc_inner(a : Array[Double], b : Array[Double]) -> Double

fn euc_ip(n : Int) -> IPSp[Array[Double]]

fn euc_max_component(a : Array[Double]) -> Double

fn euc_mean(a : Array[Double]) -> Double

fn euc_neg(a : Array[Double]) -> Array[Double]

fn euc_scale(c : Double, a : Array[Double]) -> Array[Double]

fn euc_sp(n : Int) -> VecSp[Array[Double]]

fn euc_sum(a : Array[Double]) -> Double

fn euc_zero(n : Int) -> Array[Double]

fn evec(n : Int, i : Int) -> Array[Double]

fn ext_cross3(u : Array[Double], v : Array[Double]) -> Array[Double]

fn ext_det(vectors : Array[Array[Double]]) -> Double

fn ext_from_vec(n : Int, v : Array[Double]) -> ExtVec

fn ext_hodge_star(a : ExtVec) -> ExtVec

fn ext_inner(a : ExtVec, b : ExtVec) -> Double

fn ext_interior(v : Array[Double], a : ExtVec) -> ExtVec

fn ext_ip(n : Int, k : Int) -> IPSp[ExtVec]

fn ext_norm(a : ExtVec) -> Double

fn ext_parallelogram_area(u : Array[Double], v : Array[Double]) -> Double

fn ext_wedge(a : ExtVec, b : ExtVec) -> ExtVec

fn ext_wedge_vecs(n : Int, u : Array[Double], v : Array[Double]) -> ExtVec

fn ext_zero(n : Int, k : Int) -> ExtVec

fn flat_det(data : Array[Double], n : Int) -> Double

fn fn_convolution(f : Array[Double], g : Array[Double]) -> Array[Double]

fn fn_delta_basis(n : Int) -> Array[Array[Double]]

fn fn_dft(f : Array[C]) -> Array[C]

fn fn_finite_diff(f : Array[Double]) -> Array[Double]

fn fn_idft(fc : Array[C]) -> Array[C]

fn fn_inner(f : Array[Double], g : Array[Double]) -> Double

fn fn_inner_weighted(f : Array[Double], g : Array[Double], w : Array[Double]) -> Double

fn fn_ip(n : Int, w : Array[Double]) -> IPSp[Array[Double]]

fn fn_parseval_residual(f : Array[C]) -> Double

fn fn_pointwise_mul(f : Array[Double], g : Array[Double]) -> Array[Double]

fn[V] fn_space_ip(n : Int, w : Array[Double], ip : IPSp[V]) -> IPSp[Array[V]]

fn fn_sum(f : Array[Double]) -> Double

fn hvec_add(a : HVec, b : HVec) -> HVec

fn hvec_inner(a : HVec, b : HVec) -> Double

fn hvec_ip(n : Int) -> IPSp[HVec]

fn hvec_orthonormal(vs : Array[HVec], eps : Double) -> Array[HVec]

fn hvec_real_dim(n : Int) -> Int

fn hvec_scale(c : Double, a : HVec) -> HVec

fn hvec_zero(n : Int) -> HVec

fn[V, W] inj1(a : IPSp[V], b : IPSp[W], v : V) -> (V, W)

fn[V, W] inj2(a : IPSp[V], b : IPSp[W], w : W) -> (V, W)

fn inversion_count(p : Array[Int]) -> Int

fn[V] ip_angle(ip : IPSp[V], a : V, b : V) -> Double

fn[V] ip_bessel_residual(ip : IPSp[V], v : V, onb : Array[V]) -> Double

fn[V] ip_coords(ip : IPSp[V], v : V, onb : Array[V]) -> Array[Double]

fn[V] ip_cos(ip : IPSp[V], a : V, b : V) -> Double

fn[V] ip_dist(ip : IPSp[V], a : V, b : V) -> Double

fn[V] ip_dist_subspace(ip : IPSp[V], v : V, onb : Array[V]) -> Double

fn[V] ip_from_coords(ip : IPSp[V], cs : Array[Double], onb : Array[V]) -> V

fn[V] ip_gram_matrix(ip : IPSp[V], vs : Array[V]) -> Array[Double]

fn[V] ip_gram_schmidt(ip : IPSp[V], vs : Array[V], eps : Double) -> Array[V]

fn[V] ip_is_orthogonal(ip : IPSp[V], a : V, b : V, eps : Double) -> Bool

fn[V] ip_norm(ip : IPSp[V], v : V) -> Double

fn[V] ip_normalize(ip : IPSp[V], v : V) -> V

fn[V] ip_orthonormal(ip : IPSp[V], vs : Array[V], eps : Double) -> Array[V]

fn[V] ip_proj(ip : IPSp[V], u : V, v : V) -> V

fn[V] ip_proj_coeff(ip : IPSp[V], u : V, v : V) -> Double

fn[V] ip_proj_subspace(ip : IPSp[V], v : V, onb : Array[V]) -> V

fn[V] ip_reflect(ip : IPSp[V], v : V, n_unit : V) -> V

fn[V] ip_rej(ip : IPSp[V], u : V, v : V) -> V

fn[V] ip_volume(ip : IPSp[V], vs : Array[V]) -> Double

fn[V] ips_make(sp : VecSp[V], inner : (V, V) -> Double) -> IPSp[V]

fn[V, W] ips_prod(a : IPSp[V], b : IPSp[W]) -> IPSp[(V, W)]

fn[V, W] ips_prod_weighted(a : IPSp[V], b : IPSp[W], alpha : Double, beta : Double) -> IPSp[(V, W)]

fn[V] ips_scale(ip : IPSp[V], c : Double) -> IPSp[V]

fn jacobi_eigen(a : Mat, max_sweeps : Int) -> (Array[Double], Mat)

fn least_squares(a : Mat, b : Array[Double]) -> Array[Double]

fn lu_solve(l : Mat, u : Mat, perm : Array[Int], b : Array[Double]) -> Array[Double]

fn map_direct_sum(a : Mat, b : Mat) -> Mat

fn mat_add(a : Mat, b : Mat) -> Mat

fn mat_cholesky(a : Mat) -> Mat?

fn mat_col(m : Mat, j : Int) -> Array[Double]

fn mat_col_space_basis(a : Mat, eps : Double) -> Array[Array[Double]]

fn mat_det(a : Mat) -> Double

fn mat_diag(d : Array[Double]) -> Mat

fn mat_diagonal(a : Mat) -> Array[Double]

fn mat_eq_eps(a : Mat, b : Mat, eps : Double) -> Bool

fn mat_exp(a : Mat) -> Mat

fn mat_eye(n : Int) -> Mat

fn mat_frob_inner(a : Mat, b : Mat) -> Double