pub suberror DesignError {
  Invalid(String)
  Budget(String)
  Singular(String)
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct AliasPair {
  left : String
  right : String
  correlation : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct DefiningWord {
  mask : Int
  sign : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Diagnostics {
  runs : Int
  terms : Int
  rank : Int
  residual_dof : Int
  estimable : Bool
  zero_columns : Array[String]
  exact_aliases : Array[AliasPair]
  max_abs_correlation : Double
  log_determinant : Double?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct ErrorPartition {
  residual_sse : Double
  pure_error_sse : Double
  lack_of_fit_sse : Double
  pure_error_dof : Int
  lack_of_fit_dof : Int
  f_ratio : Double?
  groups : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Factor {
  name : String
  low : Double
  high : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Fit {
  coefficients : Array[Double]
  fitted : Array[Double]
  residuals : Array[Double]
  sse : Double
  dof : Int
  variance : Double?
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Generator {
  mask : Int
  sign : Int
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct LinearConstraint {
  name : String
  coefficients : Array[Double]
  upper : Double
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct OptimalResult {
  plan : Plan
  indices : Array[Int]
  initial_logdet : Double
  final_logdet : Double
  improvements : Array[Double]
  exchanges : Int
  converged : Bool
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Plan {
  factors : Array[Factor]
  runs : Array[Run]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Run {
  id : String
  block : Int
  point : Array[Double]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

pub(all) struct Term {
  name : String
  powers : Array[Int]
} derive(Eq, 
@moonbitlang/core/debug.Debug
Debug)

fn actual_points(p : Plan) -> Array[Array[Double]] raise DesignError

fn add_centers(p : Plan, count : Int, block? : Int) -> Plan raise DesignError

fn alias_matrix(fitted : Array[Array[Double]], omitted : Array[Array[Double]], tol? : Double) -> Array[Array[Double]] raise DesignError

fn aliases(effect : Int, base : Int, generators : Array[Generator]) -> Array[DefiningWord] raise DesignError

fn augment_optimal(candidates : Plan, model : Array[Term], fixed_indices : Array[Int], total_runs : Int, passes? : Int) -> OptimalResult raise DesignError

fn balanced_blocks(p : Plan, count : Int, seed : Int) -> Plan raise DesignError

fn block_counts(p : Plan) -> Array[(Int, Int)] raise DesignError

fn box_behnken(factors : Array[Factor], centers? : Int) -> Plan raise DesignError

fn central_composite(factors : Array[Factor], alpha : Double, centers? : Int) -> Plan raise DesignError

fn coded_plan(factors : Array[Factor], points : Array[Array[Double]]) -> Plan raise DesignError

fn covariance(a : Array[Array[Double]], variance : Double, weights? : Array[Double]) -> Array[Array[Double]] raise DesignError

fn csv_records(text : String) -> Array[Array[String]] raise DesignError

fn d_optimal(candidates : Plan, model : Array[Term], count : Int, passes? : Int) -> OptimalResult raise DesignError

fn decode(f : Factor, coded : Double) -> Double raise DesignError

fn defining_relation(base : Int, generators : Array[Generator]) -> Array[DefiningWord] raise DesignError

fn design_matrix(p : Plan, model : Array[Term]) -> Array[Array[Double]] raise DesignError

fn diagnose(p : Plan, model : Array[Term], tol? : Double) -> Diagnostics raise DesignError

fn diagnostics_json(p : Plan, model : Array[Term]) -> String raise DesignError

fn effect_name(mask : Int, names : Array[String]) -> String raise DesignError

fn encode(f : Factor, actual : Double) -> Double raise DesignError

fn evaluate_terms(point : Array[Double], model : Array[Term]) -> Array[Double] raise DesignError

fn factor(name : String, low : Double, high : Double) -> Factor raise DesignError

fn factorial(factors : Array[Factor], levels : Array[Int], centers? : Int) -> Plan raise DesignError

fn filter_candidates(p : Plan, constraints : Array[LinearConstraint], tol? : Double) -> Plan raise DesignError

fn filter_points(p : Plan, predicate : (Array[Double]) -> Bool) -> Plan raise DesignError

fn fit_plan(p : Plan, model : Array[Term], responses : Array[Double]) -> Fit raise DesignError

fn foldover(p : Plan, mask : Int, include_original? : Bool) -> Plan raise DesignError

fn fraction(factors : Array[Factor], base : Int, generators : Array[Generator]) -> Plan raise DesignError

fn gradient(coefficients : Array[Double], model : Array[Term], point : Array[Double]) -> Array[Double] raise DesignError

fn information(a : Array[Array[Double]], weights? : Array[Double]) -> Array[Array[Double]] raise DesignError

fn inverse(a : Array[Array[Double]], tol? : Double) -> Array[Array[Double]] raise DesignError

fn least_squares(a : Array[Array[Double]], responses : Array[Double], weights? : Array[Double], tol? : Double) -> Fit raise DesignError

fn leverage(a : Array[Array[Double]]) -> Array[Double] raise DesignError

fn log_determinant(a : Array[Array[Double]], tol? : Double) -> Double? raise DesignError

fn matrix_rank(a : Array[Array[Double]], tol? : Double) -> Int raise DesignError

fn multiply(a : Array[Array[Double]], b : Array[Array[Double]]) -> Array[Array[Double]] raise DesignError

fn partition_error(p : Plan, model : Array[Term], responses : Array[Double], separate_blocks? : Bool) -> ErrorPartition raise DesignError

fn physical_plan(factors : Array[Factor], points : Array[Array[Double]]) -> Plan raise DesignError

fn plan(factors : Array[Factor], runs : Array[Run]) -> Plan raise DesignError

fn plan_csv(p : Plan) -> String raise DesignError

fn plan_from_csv(text : String, factors : Array[Factor]) -> Plan raise DesignError

fn plan_from_json(text : String) -> Plan raise DesignError

fn plan_json(p : Plan) -> String raise DesignError

fn predict(coefficients : Array[Double], model : Array[Term], point : Array[Double]) -> Double raise DesignError

fn prediction_variance(row : Array[Double], covariance : Array[Array[Double]]) -> Double raise DesignError

fn randomize(p : Plan, seed : Int, within_blocks? : Bool) -> Plan raise DesignError

fn refine_selection(candidates : Plan, model : Array[Term], initial : Array[Int], locked_prefix? : Int, passes? : Int) -> OptimalResult raise DesignError

fn replicate(p : Plan, copies : Int) -> Plan raise DesignError

fn resolution(base : Int, generators : Array[Generator]) -> Int? raise DesignError

fn standardized_residuals(a : Array[Array[Double]], fit : Fit) -> Array[Double?] raise DesignError

fn terms(factors : Array[Factor], order : Int) -> Array[Term] raise DesignError

fn transpose(a : Array[Array[Double]]) -> Array[Array[Double]] raise DesignError

fn two_level(factors : Array[Factor], centers? : Int) -> Plan raise DesignError

fn unique_points(p : Plan) -> Plan raise DesignError

fn validate_plan(p : Plan) -> Unit raise DesignError

fn variance_profile(p : Plan, model : Array[Term], points : Array[Array[Double]]) -> Array[Double] raise DesignError

fn within_bounds(p : Plan) -> Array[String] raise DesignError