🥮 mooncakes.io
    Sign in

    zhaoyuanjuns/moonbit_extractor/optimization does not have a README file

    CandidateAudit

    source
    pub(all) struct CandidateAudit {
      candidate : DesignCandidate
      constraints : Array[DetailedConstraintAudit]
      feasible : Bool
      total_violation : Double
      minimum_margin : Double
      status : String
    } derive(Eq, ToJson, 
    Debug    )

    ConstraintAudit

    source
    pub(all) struct ConstraintAudit {
      name : String
      value : Double
      violation : Double
      margin : Double
      passed : Bool
    } derive(Eq, ToJson, 
    Debug    )

    ConstraintKind

    source
    pub(all) enum ConstraintKind {
      AtLeast(target~ : Double)
      AtMost(target~ : Double)
      Equal(target~ : Double, tolerance~ : Double)
    } derive(Eq, ToJson, 
    Debug    )

    CoordinateSearchResult

    source
    pub(all) struct CoordinateSearchResult {
      values : Array[Double]
      objective : Double
      iterations : Int
      evaluations : Int
      converged : Bool
    } derive(Eq, ToJson, 
    Debug    )

    DesignCandidate

    source
    pub(all) struct DesignCandidate {
      values : Array[Double]
      objective : Double
      constraint_values : Array[Double]
      total_violation : Double
      feasible : Bool
      rank : Int
    } derive(Eq, ToJson, 
    Debug    )

    DesignCandidate::dominates

    source
    fn DesignCandidate::dominates(self : DesignCandidate, other : DesignCandidate) -> Bool

    DesignCandidate::new

    source
    fn DesignCandidate::new(values~ : Array[Double], objective~ : Double, constraint_values~ : Array[Double], constraints~ : ArrayView[DesignConstraint]) -> DesignCandidate raise 
    ExtractionError

    DesignCandidate::penalized_objective

    source
    fn DesignCandidate::penalized_objective(self : DesignCandidate, penalty~ : Double) -> Double raise 
    ExtractionError

    DesignConstraint

    source
    pub(all) struct DesignConstraint {
      name : String
      kind : ConstraintKind
    } derive(Eq, ToJson, 
    Debug    )

    DesignConstraint::new

    source

    DesignConstraint::passes

    source
    fn DesignConstraint::passes(self : DesignConstraint, value : Double) -> Bool

    DesignConstraint::violation

    source
    fn DesignConstraint::violation(self : DesignConstraint, value : Double) -> Double

    DesignPoint

    source
    pub(all) struct DesignPoint {
      name : String
      solvent : Double
      recovery : Double
      stages : Int
      cost : Double
    } derive(Eq, ToJson, 
    Debug    )

    DesignPoint::dominates

    source
    fn DesignPoint::dominates(self : DesignPoint, other : DesignPoint) -> Bool

    DesignSpace

    source
    pub(all) struct DesignSpace {
      variables : Array[DesignVariable]
      constraints : Array[DesignConstraint]
    } derive(Eq, ToJson, 
    Debug    )

    DesignSpace::constraints

    source
    fn DesignSpace::constraints(self : DesignSpace) -> Array[DesignConstraint]

    DesignSpace::dimension

    source
    fn DesignSpace::dimension(self : DesignSpace) -> Int

    DesignSpace::grid

    source
    fn DesignSpace::grid(self : DesignSpace) -> Array[Array[Double]]

    DesignSpace::new

    source

    DesignSpace::variables

    source
    fn DesignSpace::variables(self : DesignSpace) -> Array[DesignVariable]

    DesignVariable

    source
    pub(all) struct DesignVariable {
      name : String
      lower : Double
      upper : Double
      samples : Int
    } derive(Eq, ToJson, 
    Debug    )

    A bounded variable in a process design space.

    DesignVariable::contains

    source
    fn DesignVariable::contains(self : DesignVariable, value : Double) -> Bool

    DesignVariable::midpoint

    source
    fn DesignVariable::midpoint(self : DesignVariable) -> Double

    DesignVariable::new

    source
    fn DesignVariable::new(name~ : String, lower~ : Double, upper~ : Double, samples~ : Int) -> DesignVariable raise 
    ExtractionError

    DesignVariable::values

    source
    fn DesignVariable::values(self : DesignVariable) -> Array[Double]

    DetailedConstraintAudit

    source
    pub(all) struct DetailedConstraintAudit {
      name : String
      target : Double
      value : Double
      violation : Double
      margin : Double
      passed : Bool
      severity : String
    } derive(Eq, ToJson, 
    Debug    )

    KneePoint

    source
    pub(all) struct KneePoint {
      vector : ObjectiveVector
      distance : Double
      index : Int
    } derive(Eq, ToJson, 
    Debug    )

    ObjectiveNormalization

    source
    pub(all) struct ObjectiveNormalization {
      minimum : Array[Double]
      maximum : Array[Double]
      normalized : Array[ObjectiveVector]
    } derive(Eq, ToJson, 
    Debug    )

    ObjectiveVector

    source
    pub(all) struct ObjectiveVector {
      name : String
      values : Array[Double]
      minimize : Array[Bool]
    } derive(Eq, ToJson, 
    Debug    )

    A candidate with multiple engineering objectives.

    ObjectiveVector::dominates

    source
    fn ObjectiveVector::dominates(self : ObjectiveVector, other : ObjectiveVector) -> Bool

    ObjectiveVector::new

    source

    OptimizationSummary

    source
    pub(all) struct OptimizationSummary {
      candidates : Array[DesignCandidate]
      feasible_count : Int
      best : DesignCandidate?
      pareto_front : Array[DesignCandidate]
      evaluated : Int
    } derive(Eq, ToJson, 
    Debug    )

    RobustCandidate

    source
    pub(all) struct RobustCandidate {
      candidate : DesignCandidate
      worst_objective : Double
      mean_objective : Double
      best_objective : Double
      worst_margin : Double
      feasible_scenarios : Int
      total_scenarios : Int
      robust : Bool
    } derive(Eq, ToJson, 
    Debug    )

    RobustRanking

    source
    pub(all) struct RobustRanking {
      candidates : Array[RobustCandidate]
      selected_index : Int
      risk_tolerance : Double
      confidence : Double
    } derive(Eq, ToJson, 
    Debug    )

    ScenarioEvaluation

    source
    pub(all) struct ScenarioEvaluation {
      scenario : String
      candidate : DesignCandidate
      objective : Double
      feasible : Bool
      constraint_margin : Double
    } derive(Eq, ToJson, 
    Debug    )

    Robust design helpers for selecting operating points under scenarios.

    SearchResult

    source
    pub(all) struct SearchResult {
      argument : Double
      value : Double
      evaluations : Int
      converged : Bool
    } derive(Eq, ToJson, 
    Debug    )

    Deterministic one-dimensional search utilities for solvent sizing.

    audit_candidate

    source

    audit_candidate_detailed

    source

    audit_constraint

    source
    fn audit_constraint(constraint : DesignConstraint, value : Double) -> DetailedConstraintAudit

    audit_constraint_count

    source
    fn audit_constraint_count(audit : CandidateAudit, passed : Bool) -> Int

    audit_csv

    source
    fn audit_csv(audit : CandidateAudit) -> String

    audit_has_critical_failure

    source
    fn audit_has_critical_failure(audit : CandidateAudit) -> Bool

    audit_is_robust

    source
    fn audit_is_robust(audit : CandidateAudit, minimum_margin : Double) -> Bool

    audit_margin_vector

    source
    fn audit_margin_vector(audit : CandidateAudit) -> Array[Double]

    audit_markdown

    source
    fn audit_markdown(audit : CandidateAudit) -> String

    audit_objective

    source
    fn audit_objective(audit : CandidateAudit) -> Double

    audit_passed

    source
    fn audit_passed(audit : CandidateAudit) -> Array[DetailedConstraintAudit]

    audit_recommendation

    source
    fn audit_recommendation(audit : CandidateAudit) -> String

    audit_status_code

    source
    fn audit_status_code(audit : CandidateAudit) -> Int

    audit_summary

    source
    fn audit_summary(audit : CandidateAudit) -> String

    audit_violation_vector

    source
    fn audit_violation_vector(audit : CandidateAudit) -> Array[Double]

    audit_violations

    source
    fn audit_violations(audit : CandidateAudit) -> Array[DetailedConstraintAudit]

    audit_worst_constraint

    source
    fn audit_worst_constraint(audit : CandidateAudit) -> DetailedConstraintAudit?

    best_audit

    source
    fn best_audit(audits : ArrayView[CandidateAudit]) -> CandidateAudit?

    best_candidate

    source

    Return the best feasible candidate, preferring lower violation if none pass.

    best_case_objective

    source
    fn best_case_objective(objective_values : ArrayView[Double]) -> Double

    bounded_minimize

    source
    fn bounded_minimize(objective : (Double) -> Double raise 
    ExtractionError    , lower~ : Double, upper~ : Double, tolerance? : Double, maximum_iterations? : Int) -> SearchResult raise 
    ExtractionError

    candidate_audits

    source

    chance_constraint

    source
    fn chance_constraint(values : ArrayView[Double], limit : Double, probability : Double, lower_is_better : Bool) -> Bool raise 
    ExtractionError

    constraint_margin

    source
    fn constraint_margin(_candidate : DesignCandidate, constraint : DesignConstraint, value : Double) -> Double

    constraint_target

    source
    fn constraint_target(constraint : DesignConstraint) -> Double

    fn coordinate_search(variables : ArrayView[DesignVariable], objective : (ArrayView[Double]) -> Double raise 
    ExtractionError    , step_fraction? : Double, maximum_iterations? : Int) -> CoordinateSearchResult raise 
    ExtractionError

    Coordinate search for a bounded, derivative-free design objective.

    design_distance

    source
    fn design_distance(first : ArrayView[Double], second : ArrayView[Double]) -> Double raise 
    ExtractionError

    detailed_constraint_margin

    source
    fn detailed_constraint_margin(constraint : DesignConstraint, value : Double) -> Double

    diversity_score

    source

    evaluate_candidate_scenarios

    source
    fn evaluate_candidate_scenarios(candidate : DesignCandidate, scenarios : ArrayView[String], objective_values : ArrayView[Double], margins : ArrayView[Double], minimum_margin : Double) -> Array[ScenarioEvaluation] raise 
    ExtractionError

    evaluate_grid

    source

    feasible_audits

    source
    fn feasible_audits(audits : ArrayView[CandidateAudit]) -> Array[CandidateAudit]

    find_knee

    source

    grid_minimize

    source
    fn grid_minimize(objective : (Double) -> Double raise 
    ExtractionError    , lower~ : Double, upper~ : Double, samples~ : Int) -> SearchResult raise 
    ExtractionError

    maximum_candidate_violation

    source
    fn maximum_candidate_violation(audits : ArrayView[CandidateAudit]) -> Double

    minimum_candidate_margin

    source
    fn minimum_candidate_margin(audits : ArrayView[CandidateAudit]) -> Double

    normalize_objectives

    source

    objective_spread

    source

    pareto_candidates

    source
    fn pareto_candidates(candidates : ArrayView[DesignCandidate]) -> Array[DesignCandidate]

    pareto_front

    source
    fn pareto_front(points : ArrayView[DesignPoint]) -> Array[DesignPoint]

    pareto_layers

    source
    fn pareto_layers(vectors : ArrayView[ObjectiveVector]) -> Array[Array[ObjectiveVector]]

    rank_robust_candidates

    source
    fn rank_robust_candidates(candidates : ArrayView[RobustCandidate], risk_weight : Double, feasibility_weight : Double, risk_tolerance : Double) -> RobustRanking raise 
    ExtractionError

    regret_summary

    source
    fn regret_summary(objective_values : ArrayView[Double], minimize : Bool) -> (Double, Double, Double)

    robust_audits

    source
    fn robust_audits(audits : ArrayView[CandidateAudit], minimum_margin : Double) -> Array[CandidateAudit]

    robust_candidates

    source
    fn robust_candidates(candidates : ArrayView[RobustCandidate]) -> Array[RobustCandidate]

    robust_design_csv

    source
    fn robust_design_csv(ranking : RobustRanking) -> String

    robust_design_markdown

    source
    fn robust_design_markdown(ranking : RobustRanking) -> String

    robust_score

    source
    fn robust_score(candidate : RobustCandidate, risk_weight : Double, feasibility_weight : Double) -> Double

    robustness_index

    source
    fn robustness_index(candidate : RobustCandidate) -> Double

    safety_factor

    source
    fn safety_factor(nominal : Double, limit : Double, lower_is_better : Bool) -> Double

    scenario_regret

    source
    fn scenario_regret(objective_values : ArrayView[Double], minimize : Bool) -> Array[Double]

    scenario_weighted_mean

    source
    fn scenario_weighted_mean(values : ArrayView[Double], weights : ArrayView[Double]) -> Double raise 
    ExtractionError

    summarize_robust_candidate

    source
    fn summarize_robust_candidate(candidate : DesignCandidate, evaluations : ArrayView[ScenarioEvaluation], risk_tolerance : Double) -> RobustCandidate raise 
    ExtractionError

    weighted_objective

    source
    fn weighted_objective(vector : ObjectiveVector, weights : ArrayView[Double]) -> Double raise 
    ExtractionError

    weighted_quantile

    source
    fn weighted_quantile(values : ArrayView[Double], weights : ArrayView[Double], probability : Double) -> Double raise 
    ExtractionError

    worst_case_objective

    source
    fn worst_case_objective(objective_values : ArrayView[Double]) -> Double

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io