🥮 mooncakes.io

moonbit-vle

MoonBit vapor-liquid equilibrium toolkit with Raoult, Henry, Wilson, NRTL and UNIQUAC helpers.

vle
lle
sle
thermodynamics
phase-equilibrium
moonbit
moon add Zxy666668/moonbit-vle@0.2.2
Download zip
Author
Version
0.2.2
License
Apache-2.0
Repository
Last updated
4 hours ago
Downloads
6
README

#moonbit-vle

moonbit-vle is a reusable MoonBit toolkit for vapor–liquid equilibrium (VLE) and adjacent phase-equilibrium calculations. It targets teaching tools, small process-simulation components, property-correlation experiments, and portable WebAssembly/native applications. The library keeps molecular structure processing out of scope: callers provide component and parameter data, and the calculation layer returns reproducible equilibrium results.

#Core capabilities

  • Antoine, extended Antoine, DIPPR-101, Wagner, and Clausius–Clapeyron vapor-pressure correlations.
  • Raoult-law and Henry-law K values, bubble/dew pressure and temperature calculations.
  • Ideal Rachford–Rice flash and multicomponent activity-coefficient flash with Wilson, NRTL, and UNIQUAC models.
  • Binary and multicomponent activity matrices with dimension and parameter diagnostics.
  • Heat-capacity, latent-heat, liquid/vapor enthalpy, and ideal isenthalpic flash helpers.
  • Binary and multicomponent phase-envelope grids, equilibrium profiles, material balances, Fenske/reflux estimates, and sensitivity analysis.
  • Deterministic Antoine parameter fitting, property catalogs, source-labelled fixtures, benchmark reports, and audit APIs.

#Quick start

Add the module to a MoonBit project, or use the repository as a root module:

moon update
moon check --target all
moon test --target all

The public API is designed around normalized compositions and explicit units. Temperatures are kelvin and pressures are bar unless a function name or parameter says otherwise.

///|
test {
  let point = @moonbit-vle.bubble_temperature_k(
    @moonbit-vle.benzene_toluene(),
    [0.45, 0.55],
    1.01325,
    low_k=340.0,
    high_k=390.0,
  )
  inspect(
    point.temperature_k > 360.0 && point.temperature_k < 370.0,
    content="true",
  )
}

#CLI demo

The executable runs a benzene/toluene bubble-point calculation, an ideal activity flash, a material-balance audit, and the pure-pressure benchmark catalog:

moon run cmd/main --target wasm-gc

The demo is deterministic, so it can be used as a smoke test in local development or in a release checklist.

#API examples

Ideal and non-ideal bubble pressure:

///|
test {
  let components = @moonbit-vle.ethanol_water()
  let ideal = @moonbit-vle.bubble_pressure_bar(components, [0.4, 0.6], 351.15)
  let wilson = @moonbit-vle.bubble_pressure_bar(
    components,
    [0.4, 0.6],
    351.15,
    model=@moonbit-vle.ethanol_water_wilson(),
  )
  inspect(ideal.pressure_bar > 0.0, content="true")
  inspect(wilson.pressure_bar > ideal.pressure_bar, content="true")
}

Multicomponent activity flash:

///|
test {
  let matrix = @moonbit-vle.WilsonMatrix::new(
    lambda=[[1.0, 0.8], [1.2, 1.0]],
    source="example parameters",
  )
  let result = @moonbit-vle.flash_isothermal_activity(
    @moonbit-vle.benzene_toluene(),
    [0.5, 0.5],
    370.0,
    1.01325,
    @moonbit-vle.MulticomponentActivityModel::Wilson(matrix),
  )
  inspect(result.converged, content="true")
}

#Architecture

The root package is split by responsibility:

  • types.mbt defines public result records, error constructors, solver options, and provenance-bearing data records.
  • vapor_pressure.mbt, correlations.mbt, and properties.mbt implement property models and checked evaluation.
  • activity_models.mbt, equilibrium.mbt, flash.mbt, and flash_nonideal.mbt implement phase-equilibrium calculations.
  • solvers.mbt, units_composition.mbt, stability.mbt, and validation.mbt provide reusable numerical and input-safety infrastructure.
  • energy.mbt, phase_envelope.mbt, process_calculations.mbt, and distillation_profiles.mbt cover process-calculation workflows.
  • regression.mbt, catalog.mbt, benchmark_report.mbt, matrix_audit.mbt, and sensitivity.mbt support parameter fitting, diagnostics, reproducibility, and review.
  • cmd/main contains the runnable smoke-test demo.

All public calculations use explicit errors for invalid ranges, dimensions, fractions, and solver failures. Correlation records carry source and range metadata so that callers can choose checked or exploratory evaluation.

#Benchmarks

The repository includes rounded, source-labelled pure-property reference points and a benzene/toluene VLE fixture. They are regression fixtures and examples, not a licensed process-design database. Run the deterministic benchmark demo:

moon run cmd/main --target wasm-gc

For a detailed explanation of units, tolerances, prediction error, and source handling, see docs/benchmark-methodology.md.

#Tests and quality checks

The test suite covers success paths, pure-phase limits, matrix dimensions, correlation ranges, solver bracketing and convergence, material balances, enthalpy paths, parameter fitting, source validation, sensitivity, and malformed inputs. The canonical local checks are:

moon fmt --check
moon check --deny-warn --target all
moon build --target all
moon test --deny-warn --target all
moon test --target native
moon info
git diff --exit-code

Coverage can be inspected with:

moon test --enable-coverage --target native
moon coverage report -f summary
moon coverage analyze

#Continuous integration

GitHub Actions installs the current MoonBit CLI on Linux, macOS, and Windows, then checks formatting, all backends, builds, tests, native tests, coverage, and generated interface files. The publish workflow is manual and performs the same prepublish checks before calling moon publish; credentials are supplied only through repository secrets.

#Data and limitations

Built-in Antoine constants are public-reference or educationally rounded records with notes and temperature ranges. Binary interaction parameters are explicitly labelled examples. Replace them with validated data for design work, and preserve the source, units, fitted range, and redistribution rights when adding new records. The current activity flash uses successive substitution; strongly associating, electrolyte, reactive, and high-pressure EOS cases are outside its supported scope.

#License

Apache-2.0. See LICENSE.

#
VleError

source
pub(all) suberror VleError {
  EmptyMixture
  LengthMismatch(expected~ : Int, actual~ : Int)
  InvalidFraction(index~ : Int, value~ : Double)
  NonPositiveTemperature(Double)
  NonPositivePressure(Double)
  MissingBinaryParameter(i~ : Int, j~ : Int)
  SolverDidNotBracket(low~ : Double, high~ : Double)
  SolverDidNotConverge(iterations~ : Int)
  InvalidSolverOptions(String)
  InvalidParameter(String)
  InvalidRange(low~ : Double, high~ : Double)
} derive(Eq, 
Debug)

#
ActivityFlashResult

source
pub struct ActivityFlashResult {
  temperature_k : Double
  pressure_bar : Double
  vapor_fraction : Double
  liquid : Array[Double]
  vapor : Array[Double]
  k_values : Array[Double]
  iterations : Int
  converged : Bool
  residual : Double
} derive(
Debug)

#
ActivityFlashResult::new

source
fn ActivityFlashResult::new(temperature_k~ : Double, pressure_bar~ : Double, vapor_fraction~ : Double, liquid~ : Array[Double], vapor~ : Array[Double], k_values~ : Array[Double], iterations~ : Int, converged~ : Bool, residual~ : Double) -> ActivityFlashResult

#
ActivityModel

source
pub(all) enum ActivityModel {
  Ideal
  Wilson(WilsonBinary)
  Nrtl(NrtlBinary)
  Uniquac(UniquacBinary)
} derive(
Debug)

#
ActivityModel::ideal

source

#
Antoine

source
pub struct Antoine {
  a : Double
  b : Double
  c : Double
  t_min_k : Double
  t_max_k : Double
  note : String
} derive(
Debug)

#
Antoine::is_in_range

source
fn Antoine::is_in_range(self : Antoine, temperature_k : Double) -> Bool

#
Antoine::new

source
fn Antoine::new(a~ : Double, b~ : Double, c~ : Double, t_min_k~ : Double, t_max_k~ : Double, note~ : String) -> Antoine

#
Antoine::pressure_bar

source
fn Antoine::pressure_bar(self : Antoine, temperature_k : Double) -> Double raise VleError

#
Antoine::pressure_bar_checked

source
fn Antoine::pressure_bar_checked(self : Antoine, temperature_k : Double) -> Double raise VleError

#
AntoineFitResult

source
pub struct AntoineFitResult {
  a : Double
  b : Double
  c : Double
  rmse_bar : Double
  max_error_bar : Double
  points : Int
  converged : Bool
} derive(
Debug)

#
AntoineObservation

source
pub struct AntoineObservation {
  temperature_k : Double
  pressure_bar : Double
} derive(
Debug)

#
AntoineObservation::new

source
fn AntoineObservation::new(temperature_k~ : Double, pressure_bar~ : Double) -> AntoineObservation

#
BenchmarkPoint

source
pub struct BenchmarkPoint {
  system : String
  temperature_k : Double
  pressure_bar : Double
  liquid : Array[Double]
  vapor : Array[Double]
  source : String
  tolerance : Double
} derive(
Debug)

#
BenchmarkPoint::new

source
fn BenchmarkPoint::new(system~ : String, temperature_k~ : Double, pressure_bar~ : Double, liquid~ : Array[Double], vapor~ : Array[Double], source~ : String, tolerance~ : Double) -> BenchmarkPoint raise VleError

#
BenchmarkSummary

source
pub struct BenchmarkSummary {
  total : Int
  passed : Int
  failed : Int
  pass_rate : Double
  mean_error : Double
  max_error : Double
} derive(
Debug)

#
BinarySplitResult

source
pub struct BinarySplitResult {
  feed : Array[Double]
  distillate : Array[Double]
  bottoms : Array[Double]
  distillate_total : Double
  bottoms_total : Double
  component_balance_error : Double
} derive(
Debug)

#
BinarySplitResult::new

source
fn BinarySplitResult::new(feed~ : Array[Double], distillate~ : Array[Double], bottoms~ : Array[Double], distillate_total~ : Double, bottoms_total~ : Double, component_balance_error~ : Double) -> BinarySplitResult

#
ClausiusClapeyron

source
pub struct ClausiusClapeyron {
  reference_pressure_bar : Double
  reference_temperature_k : Double
  enthalpy_vaporization_j_per_mol : Double
  source : String
} derive(
Debug)

#
ClausiusClapeyron::boiling_temperature_k

source
fn ClausiusClapeyron::boiling_temperature_k(self : ClausiusClapeyron, pressure_bar : Double, low_k? : Double, high_k? : Double) -> Double raise VleError

#
ClausiusClapeyron::is_in_range

source
fn ClausiusClapeyron::is_in_range(self : ClausiusClapeyron, temperature_k : Double) -> Bool

#
ClausiusClapeyron::new

source
fn ClausiusClapeyron::new(reference_pressure_bar~ : Double, reference_temperature_k~ : Double, enthalpy_vaporization_j_per_mol~ : Double, source~ : String) -> ClausiusClapeyron

#
ClausiusClapeyron::pressure_bar

source
fn ClausiusClapeyron::pressure_bar(self : ClausiusClapeyron, temperature_k : Double) -> Double raise VleError

#
ClausiusClapeyron::pressure_change_ratio

source
fn ClausiusClapeyron::pressure_change_ratio(self : ClausiusClapeyron, low_temperature_k : Double, high_temperature_k : Double) -> Double raise VleError

#
Component

source
pub struct Component {
  name : String
  formula : String
  cas : String
  antoine : Antoine
} derive(
Debug)

#
Component::new

source
fn Component::new(name~ : String, formula~ : String, cas~ : String, antoine~ : Antoine) -> Component

#
Component::saturation_pressure_bar

source
fn Component::saturation_pressure_bar(self : Component, temperature_k : Double) -> Double raise VleError

#
CorrelationComparison

source
pub struct CorrelationComparison {
  name : String
  points : Int
  mean_relative_difference : Double
  maximum_relative_difference : Double
} derive(
Debug)

#
Dippr101

source
pub struct Dippr101 {
  a : Double
  b : Double
  c : Double
  d : Double
  e : Double
  t_min_k : Double
  t_max_k : Double
  source : String
} derive(
Debug)

#
Dippr101::new

source
fn Dippr101::new(a~ : Double, b~ : Double, c~ : Double, d~ : Double, e~ : Double, t_min_k~ : Double, t_max_k~ : Double, source~ : String) -> Dippr101

#
Dippr101::pressure_bar

source
fn Dippr101::pressure_bar(self : Dippr101, temperature_k : Double) -> Double raise VleError

#
EnergyFlashResult

source
pub struct EnergyFlashResult {
  temperature_k : Double
  pressure_bar : Double
  vapor_fraction : Double
  liquid : Array[Double]
  vapor : Array[Double]
  enthalpy_j_per_mol : Double
  iterations : Int
} derive(
Debug)

#
EnergyFlashResult::new

source
fn EnergyFlashResult::new(temperature_k~ : Double, pressure_bar~ : Double, vapor_fraction~ : Double, liquid~ : Array[Double], vapor~ : Array[Double], enthalpy_j_per_mol~ : Double, iterations~ : Int) -> EnergyFlashResult

#
EquilibriumAudit

source
pub struct EquilibriumAudit {
  is_valid : Bool
  maximum_composition_error : Double
  pressure_error : Double
  material_balance_error : Double
  messages : Array[String]
} derive(
Debug)

#
EquilibriumPoint

source
pub struct EquilibriumPoint {
  temperature_k : Double
  pressure_bar : Double
  liquid : Array[Double]
  vapor : Array[Double]
  iterations : Int
} derive(
Debug)

#
EquilibriumPoint::new

source
fn EquilibriumPoint::new(temperature_k~ : Double, pressure_bar~ : Double, liquid~ : Array[Double], vapor~ : Array[Double], iterations~ : Int) -> EquilibriumPoint

#
EquilibriumProfilePoint

source
pub struct EquilibriumProfilePoint {
  liquid_fraction : Double
  vapor_fraction : Double
  relative_volatility : Double
} derive(
Debug)

#
ExtendedAntoine

source
pub struct ExtendedAntoine {
  a : Double
  b : Double
  c : Double
  d : Double
  e : Double
  t_min_k : Double
  t_max_k : Double
  source : String
} derive(
Debug)

#
ExtendedAntoine::boiling_temperature_k

source
fn ExtendedAntoine::boiling_temperature_k(self : ExtendedAntoine, pressure_bar : Double, low_k? : Double, high_k? : Double) -> Double raise VleError

#
ExtendedAntoine::is_in_range

source
fn ExtendedAntoine::is_in_range(self : ExtendedAntoine, temperature_k : Double) -> Bool

#
ExtendedAntoine::new

source
fn ExtendedAntoine::new(a~ : Double, b~ : Double, c~ : Double, d~ : Double, e~ : Double, t_min_k~ : Double, t_max_k~ : Double, source~ : String) -> ExtendedAntoine

#
ExtendedAntoine::pressure_bar

source
fn ExtendedAntoine::pressure_bar(self : ExtendedAntoine, temperature_k : Double) -> Double raise VleError

#
ExtendedAntoine::pressure_bar_checked

source
fn ExtendedAntoine::pressure_bar_checked(self : ExtendedAntoine, temperature_k : Double) -> Double raise VleError

#
FlashResult

source
pub struct FlashResult {
  temperature_k : Double
  pressure_bar : Double
  vapor_fraction : Double
  liquid : Array[Double]
  vapor : Array[Double]
  iterations : Int
} derive(
Debug)

#
FlashResult::new

source
fn FlashResult::new(temperature_k~ : Double, pressure_bar~ : Double, vapor_fraction~ : Double, liquid~ : Array[Double], vapor~ : Array[Double], iterations~ : Int) -> FlashResult

#
GridSpacing

source
pub struct GridSpacing {
  count : Int
  minimum : Double
  maximum : Double
  mean : Double
} derive(
Debug)

#
HeatCapacityPolynomial

source
pub struct HeatCapacityPolynomial {
  coefficients : Array[Double]
  t_min_k : Double
  t_max_k : Double
  source : String
} derive(
Debug)

#
HeatCapacityPolynomial::derivative

source
fn HeatCapacityPolynomial::derivative(self : HeatCapacityPolynomial, temperature_k : Double) -> Double raise VleError

#
HeatCapacityPolynomial::evaluate

source
fn HeatCapacityPolynomial::evaluate(self : HeatCapacityPolynomial, temperature_k : Double) -> Double raise VleError

#
HeatCapacityPolynomial::integral

source
fn HeatCapacityPolynomial::integral(self : HeatCapacityPolynomial, low_k~ : Double, high_k~ : Double) -> Double raise VleError

#
HeatCapacityPolynomial::is_in_range

source
fn HeatCapacityPolynomial::is_in_range(self : HeatCapacityPolynomial, temperature_k : Double) -> Bool

#
HeatCapacityPolynomial::new

source
fn HeatCapacityPolynomial::new(coefficients~ : Array[Double], t_min_k~ : Double, t_max_k~ : Double, source~ : String) -> HeatCapacityPolynomial raise VleError

#
KValueDiagnostics

source
pub struct KValueDiagnostics {
  regime : PhaseRegime
  f_at_zero : Double
  f_at_one : Double
  minimum_k : Double
  maximum_k : Double
  stability_margin : Double
} derive(
Debug)

#
MatrixStatistics

source
pub struct MatrixStatistics {
  dimension : Int
  minimum : Double
  maximum : Double
  maximum_asymmetry : Double
  diagonal_error : Double
} derive(
Debug)

#
MulticomponentActivityModel

source
pub(all) enum MulticomponentActivityModel {
  Ideal
  Wilson(WilsonMatrix)
  Nrtl(NrtlMatrix)
  Uniquac(UniquacMatrix)
} derive(
Debug)

#
NrtlBinary

source
pub struct NrtlBinary {
  tau12 : Double
  tau21 : Double
  alpha : Double
  source : String
} derive(
Debug)

#
NrtlBinary::new

source
fn NrtlBinary::new(tau12~ : Double, tau21~ : Double, alpha~ : Double, source~ : String) -> NrtlBinary

#
NrtlMatrix

source
pub struct NrtlMatrix {
  tau : Array[Array[Double]]
  alpha : Array[Array[Double]]
  source : String
} derive(
Debug)

#
NrtlMatrix::new

source
fn NrtlMatrix::new(tau~ : Array[Array[Double]], alpha~ : Array[Array[Double]], source~ : String) -> NrtlMatrix

#
ParameterRecord

source
pub struct ParameterRecord {
  name : String
  value : Double
  unit : String
  lower_bound : Double
  upper_bound : Double
  source : String
} derive(
Debug)

#
ParameterRecord::new

source
fn ParameterRecord::new(name~ : String, value~ : Double, unit~ : String, lower_bound~ : Double, upper_bound~ : Double, source~ : String) -> ParameterRecord

#
ParameterValidationReport

source
pub struct ParameterValidationReport {
  valid : Bool
  issue_count : Int
  checked_count : Int
  messages : Array[String]
} derive(
Debug)

#
PhaseKind

source
pub(all) enum PhaseKind {
  Vapor
  Liquid
  Solid
} derive(Eq, 
Debug)

#
PhasePoint

source
pub struct PhasePoint {
  temperature_k : Double
  pressure_bar : Double
  composition : Array[Double]
  phase : PhaseKind
} derive(
Debug)

#
PhasePoint::new

source
fn PhasePoint::new(temperature_k~ : Double, pressure_bar~ : Double, composition~ : Array[Double], phase~ : PhaseKind) -> PhasePoint

#
PhaseRegime

source
pub(all) enum PhaseRegime {
  SingleLiquid
  TwoPhase
  SingleVapor
} derive(Eq, 
Debug)

#
PurePressureBenchmark

source
pub struct PurePressureBenchmark {
  component : String
  temperature_k : Double
  pressure_bar : Double
  source : String
  tolerance : Double
} derive(
Debug)

#
PurePressureBenchmark::new

source
fn PurePressureBenchmark::new(component~ : String, temperature_k~ : Double, pressure_bar~ : Double, source~ : String, tolerance~ : Double) -> PurePressureBenchmark raise VleError

#
ResidualMetrics

source
pub struct ResidualMetrics {
  count : Int
  mean_absolute_error : Double
  rmse : Double
  max_abs_error : Double
  max_relative_error : Double
  signed_bias : Double
} derive(
Debug)

#
SensitivityPoint

source
pub struct SensitivityPoint {
  temperature_k : Double
  pressure_bar : Double
  derivative_bar_per_k : Double
  relative_sensitivity : Double
} derive(
Debug)

#
ShortcutColumnResult

source
pub struct ShortcutColumnResult {
  minimum_stages : Double
  minimum_reflux : Double
  operating_reflux : Double
  estimated_stages : Int
  feed : Array[Double]
  distillate : Array[Double]
  bottoms : Array[Double]
} derive(
Debug)

#
SolidSolubility

source
pub struct SolidSolubility {
  component : Component
  solvent : Component
  temperature_k : Double
  mole_fraction : Double
  source : String
} derive(
Debug)

#
SolidSolubility::new

source
fn SolidSolubility::new(component~ : Component, solvent~ : Component, temperature_k~ : Double, mole_fraction~ : Double, source~ : String) -> SolidSolubility

#
SolverOptions

source
pub struct SolverOptions {
  tolerance : Double
  max_iterations : Int
} derive(
Debug)

#
SolverOptions::new

source
fn SolverOptions::new(tolerance~ : Double, max_iterations~ : Int) -> SolverOptions raise VleError

#
SolverReport

source
pub struct SolverReport {
  root : Double
  residual : Double
  iterations : Int
  converged : Bool
} derive(
Debug)

#
SolverReport::new

source
fn SolverReport::new(root~ : Double, residual~ : Double, iterations~ : Int, converged~ : Bool) -> SolverReport

#
ThermoProperty

source
pub struct ThermoProperty {
  component : Component
  molecular_weight_g_per_mol : Double
  liquid_heat_capacity : HeatCapacityPolynomial
  vapor_heat_capacity : HeatCapacityPolynomial
  reference_temperature_k : Double
  normal_boiling_temperature_k : Double
  latent_heat_j_per_mol : Double
  source : String
} derive(
Debug)

#
ThermoProperty::new

source
fn ThermoProperty::new(component~ : Component, molecular_weight_g_per_mol~ : Double, liquid_heat_capacity~ : HeatCapacityPolynomial, vapor_heat_capacity~ : HeatCapacityPolynomial, reference_temperature_k~ : Double, normal_boiling_temperature_k~ : Double, latent_heat_j_per_mol~ : Double, source~ : String) -> ThermoProperty raise VleError

#
TieLine

source
pub struct TieLine {
  temperature_k : Double
  phase_a : Array[Double]
  phase_b : Array[Double]
  source : String
} derive(
Debug)

#
TieLine::new

source
fn TieLine::new(temperature_k~ : Double, phase_a~ : Array[Double], phase_b~ : Array[Double], source~ : String) -> TieLine raise VleError

#
UniquacBinary

source
pub struct UniquacBinary {
  comp1 : UniquacComponent
  comp2 : UniquacComponent
  tau12 : Double
  tau21 : Double
  source : String
} derive(
Debug)

#
UniquacBinary::new

source
fn UniquacBinary::new(comp1~ : UniquacComponent, comp2~ : UniquacComponent, tau12~ : Double, tau21~ : Double, source~ : String) -> UniquacBinary

#
UniquacComponent

source
pub struct UniquacComponent {
  r : Double
  q : Double
} derive(
Debug)

#
UniquacComponent::new

source
fn UniquacComponent::new(r~ : Double, q~ : Double) -> UniquacComponent

#
UniquacMatrix

source
pub struct UniquacMatrix {
  r : Array[Double]
  q : Array[Double]
  tau : Array[Array[Double]]
  source : String
} derive(
Debug)

#
UniquacMatrix::new

source
fn UniquacMatrix::new(r~ : Array[Double], q~ : Array[Double], tau~ : Array[Array[Double]], source~ : String) -> UniquacMatrix

#
ValidationSummary

source
pub struct ValidationSummary {
  valid : Bool
  error_count : Int
  warning_count : Int
  messages : Array[String]
} derive(
Debug)

#
Wagner

source
pub struct Wagner {
  a : Double
  b : Double
  c : Double
  d : Double
  critical_temperature_k : Double
  critical_pressure_bar : Double
  t_min_k : Double
  t_max_k : Double
  source : String
} derive(
Debug)

#
Wagner::new

source
fn Wagner::new(a~ : Double, b~ : Double, c~ : Double, d~ : Double, critical_temperature_k~ : Double, critical_pressure_bar~ : Double, t_min_k~ : Double, t_max_k~ : Double, source~ : String) -> Wagner

#
Wagner::pressure_bar

source
fn Wagner::pressure_bar(self : Wagner, temperature_k : Double) -> Double raise VleError

#
WilsonBinary

source
pub struct WilsonBinary {
  lambda12 : Double
  lambda21 : Double
  source : String
} derive(
Debug)

#
WilsonBinary::new

source
fn WilsonBinary::new(lambda12~ : Double, lambda21~ : Double, source~ : String) -> WilsonBinary

#
WilsonMatrix

source
pub struct WilsonMatrix {
  lambda : Array[Array[Double]]
  source : String
} derive(
Debug)

#
WilsonMatrix::new

source
fn WilsonMatrix::new(lambda~ : Array[Array[Double]], source~ : String) -> WilsonMatrix

#
acetone

source
fn acetone() -> Component

#
acetone_chloroform

source
fn acetone_chloroform() -> Array[Component]

#
acetone_chloroform_nrtl

source
fn acetone_chloroform_nrtl() -> ActivityModel

#
acetone_thermo_property

source
fn acetone_thermo_property() -> ThermoProperty raise VleError

#
activity_coefficients

source
fn activity_coefficients(model : ActivityModel, liquid : Array[Double], temperature_k : Double) -> Array[Double] raise VleError

#
activity_flash_is_two_phase

source
fn activity_flash_is_two_phase(result : ActivityFlashResult) -> Bool

#
activity_flash_k_error

source
fn activity_flash_k_error(result : ActivityFlashResult, components : Array[Component], temperature_k : Double, pressure_bar : Double, model : MulticomponentActivityModel) -> Double raise VleError

#
activity_flash_material_balance_error

source
fn activity_flash_material_balance_error(result : ActivityFlashResult, feed : Array[Double]) -> Double raise VleError

#
activity_flash_phase_fractions

source
fn activity_flash_phase_fractions(result : ActivityFlashResult) -> Array[Double]

#
activity_flash_residual

source
fn activity_flash_residual(result : ActivityFlashResult) -> Double

#
antoine_fit_is_reasonable

source
fn antoine_fit_is_reasonable(result : AntoineFitResult, max_rmse_bar : Double) -> Bool raise VleError

#
antoine_fit_mean_absolute_error

source
fn antoine_fit_mean_absolute_error(result : AntoineFitResult, observations : Array[AntoineObservation]) -> Double raise VleError

#
antoine_fit_predict_many

source
fn antoine_fit_predict_many(result : AntoineFitResult, temperatures_k : Array[Double]) -> Array[Double] raise VleError

#
antoine_fit_pressure_bar

source
fn antoine_fit_pressure_bar(a : Double, b : Double, c : Double, temperature_k : Double) -> Double raise VleError

#
antoine_fit_residuals

source
fn antoine_fit_residuals(result : AntoineFitResult, observations : Array[AntoineObservation]) -> Array[Double] raise VleError

#
argmax_component

source
fn argmax_component(values : Array[Double]) -> Int raise VleError

#
argmin_component

source
fn argmin_component(values : Array[Double]) -> Int raise VleError

#
atm_to_bar

source
fn atm_to_bar(pressure_atm : Double) -> Double

#
audit_activity_flash

source
fn audit_activity_flash(result : ActivityFlashResult, feed : Array[Double]) -> EquilibriumAudit raise VleError

#
audit_equilibrium_point

source
fn audit_equilibrium_point(point : EquilibriumPoint) -> EquilibriumAudit

#
audit_error_budget

source
fn audit_error_budget(audit : EquilibriumAudit, tolerance : Double) -> Bool

#
audit_flash_result

source
fn audit_flash_result(result : FlashResult, feed : Array[Double]) -> EquilibriumAudit raise VleError

#
average_heat_capacity

source
fn average_heat_capacity(correlation : HeatCapacityPolynomial, low_k~ : Double, high_k~ : Double) -> Double raise VleError

#
bar_to_atm

source
fn bar_to_atm(pressure_bar : Double) -> Double

#
bar_to_kpa

source
fn bar_to_kpa(pressure_bar : Double) -> Double

#
bar_to_mmhg

source
fn bar_to_mmhg(pressure_bar : Double) -> Double

#
bar_to_pascal

source
fn bar_to_pascal(pressure_bar : Double) -> Double

#
benchmark_error_percent

source
fn benchmark_error_percent(reference : Double, predicted : Double) -> Double raise VleError

#
benchmark_is_within_pressure_tolerance

source
fn benchmark_is_within_pressure_tolerance(point : BenchmarkPoint, predicted_pressure_bar : Double) -> Bool

#
benchmark_prediction_from_component

source
fn benchmark_prediction_from_component(component : Component, point : PurePressureBenchmark) -> Double raise VleError

#
benchmark_pressure_error

source
fn benchmark_pressure_error(point : BenchmarkPoint, predicted_pressure_bar : Double) -> Double

#
benchmark_summary_error_budget

source
fn benchmark_summary_error_budget(summary : BenchmarkSummary, maximum_allowed_error : Double) -> Bool raise VleError

#
benchmark_summary_is_successful

source
fn benchmark_summary_is_successful(summary : BenchmarkSummary, required_pass_rate : Double) -> Bool raise VleError

#
benzene

source
fn benzene() -> Component

#
benzene_thermo_property

source
fn benzene_thermo_property() -> ThermoProperty raise VleError

#
benzene_toluene

source
fn benzene_toluene() -> Array[Component]

#
benzene_toluene_benchmarks

source
fn benzene_toluene_benchmarks() -> Array[BenchmarkPoint] raise VleError

#
benzene_toluene_uniquac

source
fn benzene_toluene_uniquac() -> ActivityModel

#
benzoic_acid_in_water_demo

source
fn benzoic_acid_in_water_demo() -> SolidSolubility

#
binary_composition_grid

source
fn binary_composition_grid(points : Int) -> Array[Array[Double]] raise VleError

#
binary_equilibrium_x

source
fn binary_equilibrium_x(vapor_light_fraction : Double, relative_volatility : Double) -> Double raise VleError

#
binary_equilibrium_y

source
fn binary_equilibrium_y(liquid_light_fraction : Double, relative_volatility : Double) -> Double raise VleError

#
blend_compositions

source
fn blend_compositions(first : Array[Double], first_amount : Double, second : Array[Double], second_amount : Double) -> Array[Double] raise VleError

#
bubble_curve_binary

source
fn bubble_curve_binary(components : Array[Component], model : MulticomponentActivityModel, pressure_bar~ : Double, points~ : Int, low_k~ : Double, high_k~ : Double) -> Array[EquilibriumPoint] raise VleError

#
bubble_pressure_bar

source
fn bubble_pressure_bar(components : Array[Component], liquid : Array[Double], temperature_k : Double, model? : ActivityModel) -> EquilibriumPoint raise VleError

#
bubble_pressure_composition_sensitivity

source
fn bubble_pressure_composition_sensitivity(components : Array[Component], liquid : Array[Double], temperature_k : Double, fraction_step : Double) -> Array[Double] raise VleError

#
bubble_pressure_multicomponent

source
fn bubble_pressure_multicomponent(components : Array[Component], liquid : Array[Double], temperature_k : Double, model : MulticomponentActivityModel) -> EquilibriumPoint raise VleError

#
bubble_pressure_temperature_sensitivity

source
fn bubble_pressure_temperature_sensitivity(components : Array[Component], liquid : Array[Double], temperature_k : Double, step_k : Double, model? : ActivityModel) -> SensitivityPoint raise VleError

#
bubble_temperature_k

source
fn bubble_temperature_k(components : Array[Component], liquid : Array[Double], pressure_bar : Double, low_k? : Double, high_k? : Double, model? : ActivityModel) -> EquilibriumPoint raise VleError

#
bubble_temperature_multicomponent

source
fn bubble_temperature_multicomponent(components : Array[Component], liquid : Array[Double], pressure_bar : Double, low_k? : Double, high_k? : Double, model : MulticomponentActivityModel) -> EquilibriumPoint raise VleError

#
celsius_to_kelvin

source
fn celsius_to_kelvin(temperature_c : Double) -> Double

#
chloroform

source
fn chloroform() -> Component

#
chloroform_thermo_property

source
fn chloroform_thermo_property() -> ThermoProperty raise VleError

#
classify_phase_regime

source
fn classify_phase_regime(k_values : Array[Double], feed : Array[Double]) -> PhaseRegime raise VleError

#
combine_independent_uncertainties

source
fn combine_independent_uncertainties(uncertainties : Array[Double]) -> Double raise VleError

#
combine_streams

source
fn combine_streams(first_flows : Array[Double], second_flows : Array[Double]) -> Array[Double] raise VleError

#
compare_antoine_to_dippr

source
fn compare_antoine_to_dippr(component : Component, dippr : Dippr101, temperatures_k : Array[Double]) -> Double raise VleError

#
compare_antoine_to_wagner

source
fn compare_antoine_to_wagner(component : Component, wagner : Wagner, temperatures_k : Array[Double]) -> Double raise VleError

#
compare_pressure_correlations

source
fn compare_pressure_correlations(reference : Component, temperatures_k : Array[Double], correlations : Array[ExtendedAntoine]) -> Array[CorrelationComparison] raise VleError

#
component_liquid_enthalpy

source
fn component_liquid_enthalpy(property : ThermoProperty, temperature_k : Double) -> Double raise VleError

#
component_phase_enthalpy

source
fn component_phase_enthalpy(property : ThermoProperty, temperature_k : Double, phase : PhaseKind) -> Double raise VleError

#
component_recovery

source
fn component_recovery(feed_flow : Double, product_flow : Double) -> Double raise VleError

#
component_vapor_enthalpy

source
fn component_vapor_enthalpy(property : ThermoProperty, temperature_k : Double) -> Double raise VleError

#
componentwise_product

source
fn componentwise_product(first : Array[Double], second : Array[Double]) -> Array[Double] raise VleError

#
componentwise_quotient

source
fn componentwise_quotient(numerator : Array[Double], denominator : Array[Double]) -> Array[Double] raise VleError

#
composition_entropy

source
fn composition_entropy(composition : Array[Double]) -> Double raise VleError

#
composition_is_valid

source
fn composition_is_valid(composition : Array[Double], tolerance : Double) -> Bool

#
composition_l1_distance

source
fn composition_l1_distance(first : Array[Double], second : Array[Double]) -> Double raise VleError

#
composition_l2_distance

source
fn composition_l2_distance(first : Array[Double], second : Array[Double]) -> Double raise VleError

#
composition_maximum

source
fn composition_maximum(composition : Array[Double]) -> Double raise VleError

#
composition_minimum

source
fn composition_minimum(composition : Array[Double]) -> Double raise VleError

#
composition_normalization_error

source
fn composition_normalization_error(composition : Array[Double]) -> Double

#
correlation_maximum_relative_difference

source
fn correlation_maximum_relative_difference(reference_pressures_bar : Array[Double], candidate_pressures_bar : Array[Double]) -> Double raise VleError

#
correlation_mean_relative_difference

source
fn correlation_mean_relative_difference(reference_pressures_bar : Array[Double], candidate_pressures_bar : Array[Double]) -> Double raise VleError

#
correlation_relative_difference

source
fn correlation_relative_difference(reference_pressure_bar : Double, candidate_pressure_bar : Double) -> Double raise VleError

#
curve_compositions_sum_to_one

source
fn curve_compositions_sum_to_one(curve : Array[EquilibriumPoint], tolerance : Double) -> Bool raise VleError

#
curve_pressure_span

source
fn curve_pressure_span(curve : Array[EquilibriumPoint]) -> Double raise VleError

#
curve_temperature_span

source
fn curve_temperature_span(curve : Array[EquilibriumPoint]) -> Double raise VleError

#
cyclohexane

source
fn cyclohexane() -> Component

#
cyclohexane_thermo_property

source
fn cyclohexane_thermo_property() -> ThermoProperty raise VleError

#
demo_acetone_chloroform_nrtl

source
fn demo_acetone_chloroform_nrtl() -> EquilibriumPoint raise VleError

#
demo_benzene_toluene_bubble

source
fn demo_benzene_toluene_bubble() -> EquilibriumPoint raise VleError

#
demo_benzene_toluene_relative_volatility

source
fn demo_benzene_toluene_relative_volatility() -> Double raise VleError

#
demo_ethanol_water_wilson

source
fn demo_ethanol_water_wilson() -> EquilibriumPoint raise VleError

#
dew_curve_binary

source
fn dew_curve_binary(components : Array[Component], model : MulticomponentActivityModel, pressure_bar~ : Double, points~ : Int, low_k~ : Double, high_k~ : Double) -> Array[EquilibriumPoint] raise VleError

#
dew_pressure_bar

source
fn dew_pressure_bar(components : Array[Component], vapor : Array[Double], temperature_k : Double, model? : ActivityModel) -> EquilibriumPoint raise VleError

#
dew_pressure_multicomponent

source
fn dew_pressure_multicomponent(components : Array[Component], vapor : Array[Double], temperature_k : Double, model : MulticomponentActivityModel) -> EquilibriumPoint raise VleError

#
dew_temperature_k

source
fn dew_temperature_k(components : Array[Component], vapor : Array[Double], pressure_bar : Double, low_k? : Double, high_k? : Double, model? : ActivityModel) -> EquilibriumPoint raise VleError

#
dew_temperature_multicomponent

source
fn dew_temperature_multicomponent(components : Array[Component], vapor : Array[Double], pressure_bar : Double, low_k? : Double, high_k? : Double, model : MulticomponentActivityModel) -> EquilibriumPoint raise VleError

#
distribution_ratio

source
fn distribution_ratio(line : TieLine, component_index : Int) -> Double

#
equilibrium_curve_slope

source
fn equilibrium_curve_slope(relative_volatility : Double, liquid_fraction : Double) -> Double raise VleError

#
equilibrium_point_is_valid

source
fn equilibrium_point_is_valid(point : EquilibriumPoint) -> Bool

#
estimate_vapor_fraction_from_enthalpy

source
fn estimate_vapor_fraction_from_enthalpy(liquid_enthalpy : Double, vapor_enthalpy : Double, target_enthalpy : Double) -> Double raise VleError

#
ethanol

source
fn ethanol() -> Component

#
ethanol_thermo_property

source
fn ethanol_thermo_property() -> ThermoProperty raise VleError

#
ethanol_water

source
fn ethanol_water() -> Array[Component]

#
ethanol_water_wilson

source
fn ethanol_water_wilson() -> ActivityModel

#
ethyl_acetate

source
fn ethyl_acetate() -> Component

#
ethyl_acetate_thermo_property

source
fn ethyl_acetate_thermo_property() -> ThermoProperty raise VleError

#
evaluate_pure_pressure_catalog

source
fn evaluate_pure_pressure_catalog(components : Array[Component], points : Array[PurePressureBenchmark]) -> BenchmarkSummary raise VleError

#
fenske_minimum_stages

source
fn fenske_minimum_stages(relative_volatility~ : Double, light_key_distillate_fraction~ : Double, light_key_bottoms_fraction~ : Double) -> Double raise VleError

#
finite_difference_condition_number

source
fn finite_difference_condition_number(base_value : Double, low_value : Double, high_value : Double, relative_step : Double) -> Double raise VleError

#
finite_difference_derivative

source
fn finite_difference_derivative(f : (Double) -> Double raise VleError, point : Double, step : Double) -> Double raise VleError

#
fit_antoine

source
fn fit_antoine(observations : Array[AntoineObservation], initial_c~ : Double, c_span~ : Double, c_steps~ : Int) -> AntoineFitResult raise VleError

#
flash_enthalpy_at_temperature

source
fn flash_enthalpy_at_temperature(properties : Array[ThermoProperty], feed : Array[Double], temperature_k : Double, pressure_bar : Double) -> Double raise VleError

#
flash_isenthalpic_ideal

source
fn flash_isenthalpic_ideal(properties : Array[ThermoProperty], feed : Array[Double], feed_temperature_k~ : Double, pressure_bar~ : Double, target_enthalpy_j_per_mol~ : Double, low_k? : Double, high_k? : Double) -> EnergyFlashResult raise VleError

#
flash_isothermal_activity

source
fn flash_isothermal_activity(components : Array[Component], feed : Array[Double], temperature_k : Double, pressure_bar : Double, model : MulticomponentActivityModel, damping? : Double, tolerance? : Double, max_iterations? : Int) -> ActivityFlashResult raise VleError

#
flash_isothermal_ideal

source
fn flash_isothermal_ideal(components : Array[Component], feed : Array[Double], temperature_k : Double, pressure_bar : Double) -> FlashResult raise VleError

#
forward_difference_derivative

source
fn forward_difference_derivative(f : (Double) -> Double raise VleError, point : Double, step : Double) -> Double raise VleError

#
generate_equilibrium_profile

source
fn generate_equilibrium_profile(relative_volatility~ : Double, points~ : Int) -> Array[EquilibriumProfilePoint] raise VleError

#
grid_is_well_formed

source
fn grid_is_well_formed(values : Array[Double], minimum_spacing~ : Double) -> Bool

#
grid_spacing

source
fn grid_spacing(values : Array[Double]) -> GridSpacing

#
heat_capacity_change

source
fn heat_capacity_change(correlation : HeatCapacityPolynomial, low_k~ : Double, high_k~ : Double) -> Double raise VleError

#
henry_k_value

source
fn henry_k_value(henry_constant_bar : Double, pressure_bar : Double) -> Double raise VleError

#
hexane_cyclohexane_benzene

source
fn hexane_cyclohexane_benzene() -> Array[Component]

#
integrate_trapezoid

source
fn integrate_trapezoid(xs : Array[Double], ys : Array[Double]) -> Double raise VleError

#
joule_to_kilojoule

source
fn joule_to_kilojoule(energy_j : Double) -> Double

#
k_value_diagnostics

source
fn k_value_diagnostics(k_values : Array[Double], feed : Array[Double]) -> KValueDiagnostics raise VleError

#
k_value_is_near_ideal

source
fn k_value_is_near_ideal(k_values : Array[Double], tolerance : Double) -> Bool raise VleError

#
k_value_span

source
fn k_value_span(k_values : Array[Double]) -> Double raise VleError

#
k_value_stability_margin

source
fn k_value_stability_margin(k_values : Array[Double], feed : Array[Double]) -> Double raise VleError

#
k_value_tangent_plane_proxy

source
fn k_value_tangent_plane_proxy(k_values : Array[Double], composition : Array[Double]) -> Double raise VleError

#
k_values

source
fn k_values(components : Array[Component], temperature_k : Double, pressure_bar : Double) -> Array[Double] raise VleError

#
kelvin_to_celsius

source
fn kelvin_to_celsius(temperature_k : Double) -> Double

#
kilojoule_to_joule

source
fn kilojoule_to_joule(energy_kj : Double) -> Double

#
kpa_to_bar

source
fn kpa_to_bar(pressure_kpa : Double) -> Double

#
latent_energy_fraction

source
fn latent_energy_fraction(property : ThermoProperty, temperature_k : Double, critical_temperature_k : Double) -> Double raise VleError

#
latent_heat_at

source
fn latent_heat_at(property : ThermoProperty, temperature_k : Double, critical_temperature_k : Double) -> Double raise VleError

#
lever_rule_fraction

source
fn lever_rule_fraction(feed : Double, raffinate : Double, extract : Double) -> Double

#
linear_interpolate

source
fn linear_interpolate(x0 : Double, y0 : Double, x1 : Double, y1 : Double, x : Double) -> Double raise VleError

#
liquid_sensible_heat_capacity

source
fn liquid_sensible_heat_capacity(property : ThermoProperty, temperature_k : Double) -> Double raise VleError

#
mass_flow_to_molar_flow

source
fn mass_flow_to_molar_flow(mass_flow_kg_per_s : Double, molecular_weight_g_per_mol : Double) -> Double raise VleError

#
mass_to_molar_fractions

source
fn mass_to_molar_fractions(mass_fractions : Array[Double], molecular_weights : Array[Double]) -> Array[Double] raise VleError

#
material_balance_error

source
fn material_balance_error(feed : Array[Double], distillate : Array[Double], bottoms : Array[Double], distillate_total : Double, bottoms_total : Double) -> Double raise VleError

#
matrix_add

source
fn matrix_add(first : Array[Array[Double]], second : Array[Array[Double]]) -> Array[Array[Double]] raise VleError

#
matrix_column_sums

source
fn matrix_column_sums(matrix : Array[Array[Double]]) -> Array[Double] raise VleError

#
matrix_determinant_2x2

source
fn matrix_determinant_2x2(matrix : Array[Array[Double]]) -> Double raise VleError

#
matrix_diagonal

source
fn matrix_diagonal(matrix : Array[Array[Double]]) -> Array[Double] raise VleError

#
matrix_frobenius_norm

source
fn matrix_frobenius_norm(matrix : Array[Array[Double]]) -> Double raise VleError

#
matrix_identity

source
fn matrix_identity(dimension : Int) -> Array[Array[Double]] raise VleError

#
matrix_is_symmetric

source
fn matrix_is_symmetric(matrix : Array[Array[Double]], tolerance : Double) -> Bool raise VleError

#
matrix_quadratic_form

source
fn matrix_quadratic_form(matrix : Array[Array[Double]], vector : Array[Double]) -> Double raise VleError

#
matrix_row_sums

source
fn matrix_row_sums(matrix : Array[Array[Double]]) -> Array[Double] raise VleError

#
matrix_scale

source
fn matrix_scale(matrix : Array[Array[Double]], scale : Double) -> Array[Array[Double]] raise VleError

#
matrix_statistics

source
fn matrix_statistics(matrix : Array[Array[Double]]) -> MatrixStatistics raise VleError

#
matrix_subtract

source
fn matrix_subtract(first : Array[Array[Double]], second : Array[Array[Double]]) -> Array[Array[Double]] raise VleError

#
matrix_trace

source
fn matrix_trace(matrix : Array[Array[Double]]) -> Double raise VleError

#
matrix_transpose

source
fn matrix_transpose(matrix : Array[Array[Double]]) -> Array[Array[Double]] raise VleError

#
matrix_vector_product

source
fn matrix_vector_product(matrix : Array[Array[Double]], vector : Array[Double]) -> Array[Double] raise VleError

#
max_abs_value

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

#
maximum_absolute_error

source
fn maximum_absolute_error(references : Array[Double], predicted : Array[Double]) -> Double raise VleError

#
mean_absolute_error

source
fn mean_absolute_error(references : Array[Double], predicted : Array[Double]) -> Double raise VleError

#
mean_k_value

source
fn mean_k_value(k_values : Array[Double]) -> Double raise VleError

#
merge_validation_summaries

source
fn merge_validation_summaries(first : ValidationSummary, second : ValidationSummary) -> ValidationSummary

#
methanol

source
fn methanol() -> Component

#
methanol_thermo_property

source
fn methanol_thermo_property() -> ThermoProperty raise VleError

#
methanol_water

source
fn methanol_water() -> Array[Component]

#
metrics_summary

source
fn metrics_summary(metrics : ResidualMetrics) -> String

#
minimum_reflux_ratio_binary

source
fn minimum_reflux_ratio_binary(feed_light_fraction~ : Double, distillate_light_fraction~ : Double, relative_volatility~ : Double) -> Double raise VleError

#
mixture_energy_gap

source
fn mixture_energy_gap(properties : Array[ThermoProperty], composition : Array[Double], temperature_k : Double) -> Double raise VleError

#
mixture_liquid_enthalpy

source
fn mixture_liquid_enthalpy(properties : Array[ThermoProperty], composition : Array[Double], temperature_k : Double) -> Double raise VleError

#
mixture_molecular_weight

source
fn mixture_molecular_weight(mole_fractions : Array[Double], molecular_weights : Array[Double]) -> Double raise VleError

#
mixture_phase_enthalpy

source
fn mixture_phase_enthalpy(properties : Array[ThermoProperty], composition : Array[Double], temperature_k : Double, phase : PhaseKind) -> Double raise VleError

#
mixture_vapor_enthalpy

source
fn mixture_vapor_enthalpy(properties : Array[ThermoProperty], composition : Array[Double], temperature_k : Double) -> Double raise VleError

#
mmhg_to_bar

source
fn mmhg_to_bar(pressure_mmhg : Double) -> Double

#
molar_flow_to_mass_flow

source
fn molar_flow_to_mass_flow(molar_flow_mol_per_s : Double, molecular_weight_g_per_mol : Double) -> Double raise VleError

#
molar_to_mass_fractions

source
fn molar_to_mass_fractions(mole_fractions : Array[Double], molecular_weights : Array[Double]) -> Array[Double] raise VleError

#
mole_fractions_to_partial_pressures

source
fn mole_fractions_to_partial_pressures(mole_fractions : Array[Double], pressure_bar : Double) -> Array[Double] raise VleError

#
monotonicity_violations

source
fn monotonicity_violations(values : Array[Double], increasing~ : Bool) -> Int

#
multicomponent_activity_coefficients

source
fn multicomponent_activity_coefficients(model : MulticomponentActivityModel, liquid : Array[Double], temperature_k : Double) -> Array[Double] raise VleError

#
n_hexane

source
fn n_hexane() -> Component

#
n_hexane_thermo_property

source
fn n_hexane_thermo_property() -> ThermoProperty raise VleError

#
normalize

source
fn normalize(xs : Array[Double]) -> Array[Double] raise VleError

#
normalized_bias

source
fn normalized_bias(metrics : ResidualMetrics) -> Double

#
normalized_sensitivity

source
fn normalized_sensitivity(derivative : Double, value : Double, scale : Double) -> Double raise VleError

#
operating_line_gap

source
fn operating_line_gap(profile_point : EquilibriumProfilePoint, reflux_ratio : Double, distillate_fraction : Double) -> Double raise VleError

#
operating_line_y

source
fn operating_line_y(liquid_fraction : Double, reflux_ratio : Double, distillate_fraction : Double) -> Double raise VleError

#
parameter_catalog_is_valid

source
fn parameter_catalog_is_valid(records : Array[ParameterRecord]) -> Bool

#
parameter_catalog_sources

source
fn parameter_catalog_sources(records : Array[ParameterRecord]) -> Array[String]

#
parameter_catalog_units

source
fn parameter_catalog_units(records : Array[ParameterRecord]) -> Array[String]

#
parameter_is_near_lower_bound

source
fn parameter_is_near_lower_bound(record : ParameterRecord, fraction : Double) -> Bool raise VleError

#
parameter_is_near_upper_bound

source
fn parameter_is_near_upper_bound(record : ParameterRecord, fraction : Double) -> Bool raise VleError

#
parameter_range_width

source
fn parameter_range_width(record : ParameterRecord) -> Double

#
parameter_record_value

source
fn parameter_record_value(records : Array[ParameterRecord], name : String) -> Double raise VleError

#
parameter_records_for_component

source
fn parameter_records_for_component(component : Component) -> Array[ParameterRecord]

#
parameter_records_in_unit

source
fn parameter_records_in_unit(records : Array[ParameterRecord], unit : String) -> Array[ParameterRecord]

#
parameter_records_with_source

source
fn parameter_records_with_source(records : Array[ParameterRecord], source_fragment : String) -> Array[ParameterRecord]

#
parameter_relative_position

source
fn parameter_relative_position(record : ParameterRecord) -> Double raise VleError

#
partial_pressures_to_mole_fractions

source
fn partial_pressures_to_mole_fractions(partial_pressures_bar : Array[Double]) -> Array[Double] raise VleError

#
pascal_to_bar

source
fn pascal_to_bar(pressure_pa : Double) -> Double

#
perturb_value

source
fn perturb_value(value : Double, relative_change : Double) -> Double raise VleError

#
phase_energy_gap

source
fn phase_energy_gap(property : ThermoProperty, temperature_k : Double) -> Double raise VleError

#
phase_regime_label

source
fn phase_regime_label(regime : PhaseRegime) -> String

#
phase_split_is_balanced

source
fn phase_split_is_balanced(feed : Array[Double], liquid : Array[Double], vapor : Array[Double], vapor_fraction : Double, tolerance : Double) -> Bool raise VleError

#
phase_split_residual

source
fn phase_split_residual(feed : Array[Double], liquid : Array[Double], vapor : Array[Double], vapor_fraction : Double) -> Double raise VleError

#
pressure_catalog_components

source
fn pressure_catalog_components() -> Array[Component]

#
pressure_catalog_summary

source
fn pressure_catalog_summary() -> BenchmarkSummary raise VleError

#
pressure_sensitivity_ratio

source
fn pressure_sensitivity_ratio(component : Component, low_temperature_k : Double, high_temperature_k : Double, step_k : Double) -> Double raise VleError

#
pressure_uncertainty_from_temperature

source
fn pressure_uncertainty_from_temperature(sensitivity : SensitivityPoint, temperature_uncertainty_k : Double) -> Double raise VleError

#
profile_area

source
fn profile_area(profile : Array[EquilibriumProfilePoint]) -> Double raise VleError

#
profile_average_gap

source
fn profile_average_gap(profile : Array[EquilibriumProfilePoint]) -> Double raise VleError

#
profile_gap_integral

source
fn profile_gap_integral(profile : Array[EquilibriumProfilePoint], low_fraction : Double, high_fraction : Double) -> Double raise VleError

#
profile_interpolate

source
fn profile_interpolate(profile : Array[EquilibriumProfilePoint], liquid_fraction : Double) -> Double raise VleError

#
profile_is_ordered

source
fn profile_is_ordered(profile : Array[EquilibriumProfilePoint]) -> Bool

#
profile_maximum_gap

source
fn profile_maximum_gap(profile : Array[EquilibriumProfilePoint]) -> Double raise VleError

#
profile_minimum_gap

source
fn profile_minimum_gap(profile : Array[EquilibriumProfilePoint]) -> Double raise VleError

#
profile_operating_line_crossings

source
fn profile_operating_line_crossings(profile : Array[EquilibriumProfilePoint], reflux_ratio : Double, distillate_fraction : Double) -> Int raise VleError

#
profile_points_above_operating_line

source
fn profile_points_above_operating_line(profile : Array[EquilibriumProfilePoint], reflux_ratio : Double, distillate_fraction : Double) -> Int raise VleError

#
profile_separation_index

source
fn profile_separation_index(profile : Array[EquilibriumProfilePoint]) -> Double raise VleError

#
public_parameter_catalog

source
fn public_parameter_catalog() -> Array[ParameterRecord]

#
public_thermo_property_catalog

source
fn public_thermo_property_catalog() -> Array[ThermoProperty] raise VleError

#
pure_pressure_benchmarks

source
fn pure_pressure_benchmarks() -> Array[PurePressureBenchmark] raise VleError

#
q_line_intersection

source
fn q_line_intersection(feed_light_fraction : Double, q_value : Double, equilibrium_relative_volatility : Double) -> (Double, Double) raise VleError

#
quality_gate

source
fn quality_gate(metrics : ResidualMetrics, max_rmse~ : Double, max_relative_error~ : Double) -> Bool

#
raoult_k_value

source
fn raoult_k_value(component : Component, temperature_k : Double, pressure_bar : Double) -> Double raise VleError

#
reconstruct_phase_feed

source
fn reconstruct_phase_feed(liquid : Array[Double], vapor : Array[Double], vapor_fraction : Double) -> Array[Double] raise VleError

#
relative_error

source
fn relative_error(reference : Double, predicted : Double) -> Double raise VleError

#
relative_sensitivity_from_perturbation

source
fn relative_sensitivity_from_perturbation(base_value : Double, perturbed_value : Double, relative_perturbation : Double) -> Double raise VleError

#
relative_volatility

source
fn relative_volatility(component_a : Component, component_b : Component, temperature_k : Double) -> Double raise VleError

#
residual_metrics

source
fn residual_metrics(references : Array[Double], predicted : Array[Double]) -> ResidualMetrics

#
residual_vector

source
fn residual_vector(references : Array[Double], predicted : Array[Double]) -> Array[Double]

#
root_mean_square_error

source
fn root_mean_square_error(references : Array[Double], predicted : Array[Double]) -> Double raise VleError

#
sample_polynomial

source
fn sample_polynomial(correlation : HeatCapacityPolynomial, low_k~ : Double, high_k~ : Double, count~ : Int) -> Array[Double] raise VleError

#
saturation_pressure_sensitivity

source
fn saturation_pressure_sensitivity(component : Component, temperature_k : Double, step_k : Double) -> SensitivityPoint raise VleError

#
saturation_pressures_bar

source
fn saturation_pressures_bar(components : Array[Component], temperature_k : Double) -> Array[Double] raise VleError

#
scale_composition

source
fn scale_composition(composition : Array[Double], scale : Double) -> Array[Double] raise VleError

#
sensible_energy_between

source
fn sensible_energy_between(property : ThermoProperty, low_temperature_k : Double, high_temperature_k : Double, phase : PhaseKind) -> Double raise VleError

#
sensitivity_is_monotone_positive

source
fn sensitivity_is_monotone_positive(profile : Array[SensitivityPoint]) -> Bool

#
sensitivity_profile_maximum

source
fn sensitivity_profile_maximum(profile : Array[SensitivityPoint]) -> SensitivityPoint raise VleError

#
sensitivity_profile_mean

source
fn sensitivity_profile_mean(profile : Array[SensitivityPoint]) -> Double raise VleError

#
shortcut_distillation_binary

source
fn shortcut_distillation_binary(feed : Array[Double], relative_volatility~ : Double, light_key_distillate_fraction~ : Double, light_key_bottoms_fraction~ : Double, reflux_multiplier? : Double) -> ShortcutColumnResult raise VleError

#
solve_bisection

source
fn solve_bisection(low~ : Double, high~ : Double, options~ : SolverOptions, f : (Double) -> Double raise VleError) -> SolverReport raise VleError

#
solve_newton

source
fn solve_newton(initial~ : Double, low~ : Double, high~ : Double, options~ : SolverOptions, f : (Double) -> Double raise VleError, derivative : (Double) -> Double raise VleError) -> SolverReport raise VleError

#
split_binary_stream

source
fn split_binary_stream(feed : Array[Double], light_key_recovery~ : Double, heavy_key_recovery~ : Double) -> BinarySplitResult raise VleError

#
split_stream_by_fraction

source
fn split_stream_by_fraction(flows : Array[Double], first_fraction : Double) -> (Array[Double], Array[Double]) raise VleError

#
stream_component_flows

source
fn stream_component_flows(composition : Array[Double], total_moles : Double) -> Array[Double] raise VleError

#
stream_composition_from_flows

source
fn stream_composition_from_flows(flows : Array[Double]) -> Array[Double] raise VleError

#
stream_total_moles

source
fn stream_total_moles(flows : Array[Double]) -> Double raise VleError

#
summarize_pressure_benchmarks

source
fn summarize_pressure_benchmarks(points : Array[PurePressureBenchmark], predicted_pressures_bar : Array[Double]) -> BenchmarkSummary raise VleError

#
summarize_vle_benchmarks

source
fn summarize_vle_benchmarks(points : Array[BenchmarkPoint], predicted_pressures_bar : Array[Double]) -> BenchmarkSummary raise VleError

#
symmetric_perturbations

source
fn symmetric_perturbations(value : Double, relative_change : Double) -> (Double, Double) raise VleError

#
temperature_sensitivity_profile

source
fn temperature_sensitivity_profile(component : Component, temperatures_k : Array[Double], step_k : Double) -> Array[SensitivityPoint] raise VleError

#
toluene

source
fn toluene() -> Component

#
toluene_thermo_property

source
fn toluene_thermo_property() -> ThermoProperty raise VleError

#
validate_array_length

source
fn validate_array_length(actual : Int, expected : Int) -> ValidationSummary

#
validate_binary_parameters

source
fn validate_binary_parameters(first : Double, second : Double, tolerance : Double) -> ValidationSummary

#
validate_component_name

source
fn validate_component_name(name : String) -> ValidationSummary

#
validate_composition_for_model

source
fn validate_composition_for_model(composition : Array[Double], expected_dimension : Int) -> ValidationSummary

#
validate_correlation_pair

source
fn validate_correlation_pair(lower_temperature_k : Double, upper_temperature_k : Double, lower_pressure_bar : Double, upper_pressure_bar : Double) -> ValidationSummary

#
validate_k_values

source
fn validate_k_values(k_values : Array[Double]) -> Unit raise VleError

#
validate_molecular_weights

source
fn validate_molecular_weights(weights : Array[Double]) -> Unit raise VleError

#
validate_parameter_records

source
fn validate_parameter_records(records : Array[ParameterRecord]) -> ParameterValidationReport

#
validate_phase_point

source
fn validate_phase_point(point : PhasePoint) -> ValidationSummary

#
validate_pressure_prediction

source
fn validate_pressure_prediction(reference_pressure_bar : Double, predicted_pressure_bar : Double, tolerance_bar : Double) -> ValidationSummary

#
validate_pressure_range

source
fn validate_pressure_range(pressure_bar : Double, low_bar : Double, high_bar : Double) -> ValidationSummary

#
validate_property_catalog

source
fn validate_property_catalog(properties : Array[ThermoProperty]) -> ValidationSummary

#
validate_solver_options

source
fn validate_solver_options(options : SolverOptions) -> ValidationSummary

#
validate_source_metadata

source
fn validate_source_metadata(source_name : String, source_description : String) -> ValidationSummary

#
validate_square_matrix

source
fn validate_square_matrix(matrix : Array[Array[Double]], dimension : Int) -> Bool raise VleError

#
validate_temperature_delta

source
fn validate_temperature_delta(temperature_delta_k : Double, maximum_delta_k : Double) -> ValidationSummary

#
validate_temperature_range

source
fn validate_temperature_range(temperature_k : Double, low_k : Double, high_k : Double) -> ValidationSummary

#
validate_thermo_inputs

source
fn validate_thermo_inputs(components~ : Array[Component], composition~ : Array[Double], temperature_k~ : Double, pressure_bar~ : Double) -> ValidationSummary

#
validate_thermo_property

source
fn validate_thermo_property(property : ThermoProperty) -> ValidationSummary

#
validate_unit_name

source
fn validate_unit_name(unit : String) -> ValidationSummary

#
validation_has_errors

source
fn validation_has_errors(summary : ValidationSummary) -> Bool

#
validation_has_warning

source
fn validation_has_warning(summary : ValidationSummary) -> Bool

#
validation_is_strict

source
fn validation_is_strict(summary : ValidationSummary) -> Bool

#
validation_message_count

source
fn validation_message_count(summary : ValidationSummary) -> Int

#
validation_risk_score

source
fn validation_risk_score(summary : ValidationSummary) -> Double

#
validation_score_passes

source
fn validation_score_passes(summary : ValidationSummary, maximum_score : Double) -> Bool

#
validation_summary_is_empty

source
fn validation_summary_is_empty(summary : ValidationSummary) -> Bool

#
van_t_hoff_solid_solubility

source
fn van_t_hoff_solid_solubility(melting_temperature_k~ : Double, fusion_enthalpy_j_per_mol~ : Double, temperature_k~ : Double) -> Double raise VleError

#
vapor_sensible_heat_capacity

source
fn vapor_sensible_heat_capacity(property : ThermoProperty, temperature_k : Double) -> Double raise VleError

#
vector_distance

source
fn vector_distance(a : Array[Double], b : Array[Double]) -> Double raise VleError

#
water

source
fn water() -> Component

#
water_thermo_property

source
fn water_thermo_property() -> ThermoProperty raise VleError

#
watson_latent_heat

source
fn watson_latent_heat(reference_latent_heat_j_per_mol~ : Double, reference_temperature_k~ : Double, critical_temperature_k~ : Double, temperature_k~ : Double) -> Double raise VleError

#
watt_to_joule_per_second

source
fn watt_to_joule_per_second(power_w : Double) -> Double

#
watts_per_mol_to_joules_per_mol

source
fn watts_per_mol_to_joules_per_mol(value : Double) -> Double

#
weighted_average

source
fn weighted_average(values : Array[Double], weights : Array[Double]) -> Double raise VleError

#
weighted_phase_enthalpy

source
fn weighted_phase_enthalpy(liquid_enthalpy : Double, vapor_enthalpy : Double, vapor_fraction : Double) -> Double raise VleError

#
weighted_rms

source
fn weighted_rms(expected : Array[Double], actual : Array[Double]) -> Double raise VleError

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io