🥮 mooncakes.io

moonbit-chemreport

A MoonBit-native report layer for chemical engineering calculations.

chemistry
report
engineering
markdown
html
json
moon add lllg123/moonbit-chemreport@0.3.0
Download zip
Author
Version
0.3.0
License
Apache-2.0
Repository
Last updated
38 minutes ago
Downloads
4
README

#moonbit-chemreport

moonbit-chemreport is a MoonBit-native reporting and engineering calculation layer for process engineering software. It turns assumptions, inputs, formulas, balances, results, warnings, sources, and scenario sweeps into one deterministic model for people, scripts, and CI.

#Project positioning

The package is an integration layer, not a process simulator or a thermodynamic property database. It is designed for reactor, distillation, absorption, heat-exchanger, pump, and mass-balance packages that need reproducible calculation evidence and consistent exports.

#Core capabilities

  • Typed ChemReport model with validation and quality gates.
  • Markdown, HTML, JSON, CSV, and table exports from shared data.
  • Unit-aware quantities with dimensional compatibility checks and temperature validation.
  • Material and energy balance closure, recovery, residual, and limiting-component analysis.
  • Reactor, distillation, heat-exchanger, pump, pressure-drop, and safety-review calculations.
  • Statistical summaries, percentiles, moving averages, control limits, and deterministic sweeps.
  • Batch reporting, report comparison, diagnostics, and export benchmarks.

#Quick start

moon update
moon check --target all --deny-warn
moon test --target all --deny-warn
moon run cmd/main

The package has no runtime dependency outside the MoonBit standard toolchain. The CLI prints a Markdown preview followed by the same report encoded as JSON.

#CLI

moon run cmd/main

The CLI is intentionally small: it exercises the public package as a consumer would, keeping the example aligned with the library API.

#Architecture

AreaFilesResponsibility
Domain modelmoonbit-chemreport.mbtReport records, enums, and constructors
Exportersmarkdown_export.mbt, html_export.mbt, json_export.mbt, table.mbtDeterministic human and machine output
Engineering mathunits.mbt, balance.mbt, process_calculations.mbtUnits, balances, equipment and safety calculations
Scenario analysisanalytics.mbt, scenario_engine.mbtStatistics, control limits, sweeps, and sensitivity
Qualityvalidate.mbt, quality.mbt, diagnostics.mbtValidation, diagnostics, regression and publish gates
Integrationreport_pipeline.mbt, benchmark.mbtBuilders, batches, and reproducible export measurements

Public concrete types live in the root package so downstream packages can construct and inspect them without depending on internal implementation paths.

#Benchmark

The benchmark is executable and measures the bytes produced by all three primary exporters over a chosen number of iterations:

let result = benchmark_exports([example_chemreport()], 100)
println(result.to_markdown())

It reports Markdown, HTML, JSON, total, and average bytes. This is an export-size proxy, not a claim about a particular machine's wall-clock performance; run it in the target CI environment when comparing revisions.

#Testing

Tests cover public behavior and boundary cases including incompatible units, absolute-zero validation, balance tolerance, empty and singleton statistics, control-limit classification, HTML/Markdown/CSV escaping, quality gates, and benchmark reproducibility.

moon test --target all --deny-warn
moon test --target native --enable-coverage
moon coverage report -f summary
moon coverage analyze

#CI

.github/workflows/check.yml runs on Ubuntu, macOS, and Windows. Each job installs the current stable MoonBit CLI, updates dependencies, checks all targets, runs tests including native tests and coverage, verifies formatting and generated interfaces, and exercises the CLI.

moon info output is checked into the change review so accidental public API changes remain visible.

#License

Apache-2.0. See LICENSE.

#
Assumption

source
pub struct Assumption {
  statement : String
  impact : String
} derive(Eq, 
Debug)

#
BatchReport

source
pub struct BatchReport {
  reports : Array[ChemReport]
  labels : Array[String]
} derive(Eq, 
Debug)

#
BatchReport::all_formats

source
fn BatchReport::all_formats(self : BatchReport) -> Array[ExportBundle]

#
BatchReport::benchmark

source
fn BatchReport::benchmark(self : BatchReport, iterations : Int) -> BenchmarkResult

#
BatchReport::count

source
fn BatchReport::count(self : BatchReport) -> Int

#
BatchReport::critical_count

source
fn BatchReport::critical_count(self : BatchReport) -> Int

#
BatchReport::invalid_count

source
fn BatchReport::invalid_count(self : BatchReport) -> Int

#
BatchReport::result_count

source
fn BatchReport::result_count(self : BatchReport) -> Int

#
BatchReport::summary

source
fn BatchReport::summary(self : BatchReport) -> String

#
BatchReport::to_json

source
fn BatchReport::to_json(self : BatchReport) -> String

#
BatchReport::to_markdown

source
fn BatchReport::to_markdown(self : BatchReport) -> String

#
BatchReport::valid_count

source
fn BatchReport::valid_count(self : BatchReport) -> Int

#
BatchReport::warning_count

source
fn BatchReport::warning_count(self : BatchReport) -> Int

#
BenchmarkResult

source
pub struct BenchmarkResult {
  iterations : Int
  reports : Int
  markdown_bytes : Int
  html_bytes : Int
  json_bytes : Int
} derive(Eq, 
Debug)

#
BenchmarkResult::average_bytes

source
fn BenchmarkResult::average_bytes(self : BenchmarkResult) -> Float

#
BenchmarkResult::to_markdown

source
fn BenchmarkResult::to_markdown(self : BenchmarkResult) -> String

#
BenchmarkResult::total_bytes

source
fn BenchmarkResult::total_bytes(self : BenchmarkResult) -> Int

#
ChemReport

source
pub struct ChemReport {
  metadata : ReportMetadata
  summary : String
  assumptions : Array[Assumption]
  inputs : Array[InputValue]
  formulas : Array[FormulaNote]
  results : Array[ResultValue]
  warnings : Array[WarningNote]
  sources : Array[SourceRef]
  sections : Array[ReportSection]
  tags : Array[String]
} derive(Eq, 
Debug)

#
ChemReport::diagnostics

source
fn ChemReport::diagnostics(self : ChemReport) -> DiagnosticReport

#
ChemReport::export_table

source
fn ChemReport::export_table(self : ChemReport) -> ReportTable

#
ChemReport::format

source
fn ChemReport::format(self : ChemReport, format : String) -> String

#
ChemReport::format_names

source
fn ChemReport::format_names(_self : ChemReport) -> Array[String]

#
ChemReport::has_blocking_diagnostics

source
fn ChemReport::has_blocking_diagnostics(self : ChemReport) -> Bool

#
ChemReport::has_tag

source
fn ChemReport::has_tag(self : ChemReport, tag : String) -> Bool

#
ChemReport::is_publish_ready

source
fn ChemReport::is_publish_ready(self : ChemReport) -> Bool

#
ChemReport::render_all_formats

source
fn ChemReport::render_all_formats(self : ChemReport) -> ExportBundle

#
ChemReport::result_names

source
fn ChemReport::result_names(self : ChemReport) -> Array[String]

#
ChemReport::source_table

source
fn ChemReport::source_table(self : ChemReport) -> ReportTable

#
ChemReport::to_html

source
fn ChemReport::to_html(self : ChemReport) -> String

#
ChemReport::to_json

source
fn ChemReport::to_json(self : ChemReport) -> String

#
ChemReport::to_markdown

source
fn ChemReport::to_markdown(self : ChemReport) -> String

#
ChemReport::validate

source
fn ChemReport::validate(self : ChemReport) -> Array[ValidationIssue]

#
ChemReport::warning_count

source
fn ChemReport::warning_count(self : ChemReport, severity : WarningSeverity) -> Int

#
ChemReport::warning_table

source
fn ChemReport::warning_table(self : ChemReport) -> ReportTable

#
ChemReport::with_metadata

source
fn ChemReport::with_metadata(self : ChemReport, metadata : ReportMetadata) -> ChemReport

#
ChemReport::with_results

source
fn ChemReport::with_results(self : ChemReport, results : Array[ResultValue]) -> ChemReport

#
ChemReport::with_sources

source
fn ChemReport::with_sources(self : ChemReport, sources : Array[SourceRef]) -> ChemReport

#
ChemReport::with_summary

source
fn ChemReport::with_summary(self : ChemReport, summary : String) -> ChemReport

#
ChemReport::with_tag

source
fn ChemReport::with_tag(self : ChemReport, tag : String) -> ChemReport

#
ChemReport::with_warnings

source
fn ChemReport::with_warnings(self : ChemReport, warnings : Array[WarningNote]) -> ChemReport

#
ChemReport::without_critical_warnings

source
fn ChemReport::without_critical_warnings(self : ChemReport) -> ChemReport

#
ComponentBalance

source
pub struct ComponentBalance {
  component : String
  inlet : Float
  outlet : Float
  net : Float
  relative_error : Float
} derive(Eq, 
Debug)

#
ComponentFlow

source
pub struct ComponentFlow {
  component : String
  value : Float
  unit : MeasureUnit
} derive(Eq, 
Debug)

#
ControlLimits

source
pub struct ControlLimits {
  center : Float
  upper : Float
  lower : Float
} derive(Eq, 
Debug)

#
ControlLimits::contains

source
fn ControlLimits::contains(self : ControlLimits, value : Float) -> Bool

#
ControlLimits::flag

source
fn ControlLimits::flag(self : ControlLimits, values : Array[Float]) -> Array[ObservationFlag]

#
Diagnostic

source
pub struct Diagnostic {
  code : String
  severity : DiagnosticSeverity
  path : String
  message : String
  remediation : String
} derive(Eq, 
Debug)

#
Diagnostic::is_blocking

source
fn Diagnostic::is_blocking(self : Diagnostic) -> Bool

#
Diagnostic::level

source
fn Diagnostic::level(self : Diagnostic) -> String

#
DiagnosticReport

source
pub struct DiagnosticReport {
  diagnostics : Array[Diagnostic]
  passed : Bool
} derive(Eq, 
Debug)

#
DiagnosticReport::blocking_count

source
fn DiagnosticReport::blocking_count(self : DiagnosticReport) -> Int

#
DiagnosticReport::count

source
fn DiagnosticReport::count(self : DiagnosticReport) -> Int

#
DiagnosticReport::errors

source

#
DiagnosticReport::to_markdown

source
fn DiagnosticReport::to_markdown(self : DiagnosticReport) -> String

#
DiagnosticReport::warnings

source

#
DiagnosticSeverity

source
pub enum DiagnosticSeverity {
  DiagHint
  DiagWarning
  DiagError
  DiagBlocker
} derive(Eq, 
Debug)

#
DistillationCase

source
pub struct DistillationCase {
  feed_rate : Float
  feed_fraction : Float
  distillate_rate : Float
  distillate_fraction : Float
  bottoms_rate : Float
  bottoms_fraction : Float
  reflux_ratio : Float
  stages : Int
} derive(Eq, 
Debug)

#
DistillationCase::component_balance

source
fn DistillationCase::component_balance(self : DistillationCase) -> Float

#
DistillationCase::is_closed

source
fn DistillationCase::is_closed(self : DistillationCase, tolerance? : Float) -> Bool

#
DistillationCase::minimum_stages

source
fn DistillationCase::minimum_stages(self : DistillationCase) -> Int

#
DistillationCase::recovery

source
fn DistillationCase::recovery(self : DistillationCase) -> Float

#
DistillationCase::total_balance

source
fn DistillationCase::total_balance(self : DistillationCase) -> Float

#
EnergyBalance

source
pub struct EnergyBalance {
  inlet : Float
  outlet : Float
  residual : Float
  streams : Array[EnergyStream]
} derive(Eq, 
Debug)

#
EnergyBalance::is_closed

source
fn EnergyBalance::is_closed(self : EnergyBalance, tolerance? : Float) -> Bool

#
EnergyBalance::specific_duty

source
fn EnergyBalance::specific_duty(self : EnergyBalance, mass : Quantity) -> Result[Quantity, QuantityError]

#
EnergyStream

source
pub struct EnergyStream {
  name : String
  duty : Quantity
  direction : StreamDirection
} derive(Eq, 
Debug)

#
ExportBundle

source
pub struct ExportBundle {
  markdown : String
  html : String
  json : String
} derive(Eq, 
Debug)

#
FormulaNote

source
pub struct FormulaNote {
  name : String
  expression : String
  explanation : String
} derive(Eq, 
Debug)

#
HeatExchangerCase

source
pub struct HeatExchangerCase {
  hot_inlet : Float
  hot_outlet : Float
  cold_inlet : Float
  cold_outlet : Float
  hot_capacity_rate : Float
  cold_capacity_rate : Float
  area : Float
  overall_u : Float
} derive(Eq, 
Debug)

#
HeatExchangerCase::area_margin

source
fn HeatExchangerCase::area_margin(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::cold_duty

source
fn HeatExchangerCase::cold_duty(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::duty_residual

source
fn HeatExchangerCase::duty_residual(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::effectiveness

source
fn HeatExchangerCase::effectiveness(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::estimated_area

source
fn HeatExchangerCase::estimated_area(self : HeatExchangerCase) -> Float

#
HeatExchangerCase::hot_duty

source
fn HeatExchangerCase::hot_duty(self : HeatExchangerCase) -> Float

#
InputValue

source
pub struct InputValue {
  name : String
  value : String
  unit : String?
  note : String?
} derive(Eq, 
Debug)

#
MaterialBalance

source
pub struct MaterialBalance {
  components : Array[ComponentBalance]
  total_inlet : Float
  total_outlet : Float
} derive(Eq, 
Debug)

#
MaterialBalance::closure_percent

source
fn MaterialBalance::closure_percent(self : MaterialBalance) -> Float

#
MaterialBalance::component

source
fn MaterialBalance::component(self : MaterialBalance, name : String) -> ComponentBalance?

#
MaterialBalance::is_closed

source
fn MaterialBalance::is_closed(self : MaterialBalance, tolerance? : Float) -> Bool

#
MaterialBalance::limiting_component

source
fn MaterialBalance::limiting_component(self : MaterialBalance) -> String?

#
MaterialBalance::to_markdown

source
fn MaterialBalance::to_markdown(self : MaterialBalance) -> String

#
MaterialProperty

source
pub struct MaterialProperty {
  name : String
  molecular_weight : Float
  density : Float
  heat_capacity : Float
  boiling_point : Float
  safety_limit : Float
} derive(Eq, 
Debug)

#
MaterialProperty::is_valid

source
fn MaterialProperty::is_valid(self : MaterialProperty) -> Bool

#
MaterialProperty::thermal_capacity

source
fn MaterialProperty::thermal_capacity(self : MaterialProperty, mass : Float) -> Float

#
MeasureUnit

source
pub enum MeasureUnit {
  Kilogram
  Gram
  Tonne
  KgPerHour
  Mol
  Kmol
  Liter
  CubicMeter
  CubicMeterPerHour
  Meter
  Pascal
  KiloPascal
  Bar
  Joule
  KiloJoule
  KiloWatt
  Celsius
  Kelvin
  Second
  Minute
  Hour
  Percent
  Ratio
} derive(Eq, 
Debug)

#
MeasureUnit::dimension

source
fn MeasureUnit::dimension(self : MeasureUnit) -> UnitDimension

#
MeasureUnit::symbol

source
fn MeasureUnit::symbol(self : MeasureUnit) -> String

#
ObservationFlag

source
pub enum ObservationFlag {
  NormalObservation
  AboveControlLimit
  BelowControlLimit
} derive(Eq, 
Debug)

#
PressureDropCase

source
pub struct PressureDropCase {
  length : Float
  diameter : Float
  velocity : Float
  density : Float
  viscosity : Float
  roughness : Float
  fittings_k : Float
} derive(Eq, 
Debug)

#
PressureDropCase::friction_factor

source
fn PressureDropCase::friction_factor(self : PressureDropCase) -> Float

#
PressureDropCase::major_loss

source
fn PressureDropCase::major_loss(self : PressureDropCase) -> Float

#
PressureDropCase::minor_loss

source
fn PressureDropCase::minor_loss(self : PressureDropCase) -> Float

#
PressureDropCase::reynolds

source
fn PressureDropCase::reynolds(self : PressureDropCase) -> Float

#
PressureDropCase::total_loss

source
fn PressureDropCase::total_loss(self : PressureDropCase) -> Float

#
ProcessStream

source
pub struct ProcessStream {
  name : String
  direction : StreamDirection
  components : Array[ComponentFlow]
} derive(Eq, 
Debug)

#
PumpCase

source
pub struct PumpCase {
  flow_rate : Float
  differential_pressure : Float
  efficiency : Float
  fluid_density : Float
  installed_power : Float
} derive(Eq, 
Debug)

#
PumpCase::hydraulic_power

source
fn PumpCase::hydraulic_power(self : PumpCase) -> Float

#
PumpCase::is_overloaded

source
fn PumpCase::is_overloaded(self : PumpCase) -> Bool

#
PumpCase::power_margin

source
fn PumpCase::power_margin(self : PumpCase) -> Float

#
PumpCase::shaft_power

source
fn PumpCase::shaft_power(self : PumpCase) -> Float

#
PumpCase::specific_speed

source
fn PumpCase::specific_speed(self : PumpCase, head : Float) -> Float

#
QualityGate

source
pub struct QualityGate {
  passed : Bool
  blockers : Array[String]
  notices : Array[String]
} derive(Eq, 
Debug)

#
Quantity

source
pub struct Quantity {
  value : Float
  unit : MeasureUnit
} derive(Eq, 
Debug)

#
Quantity::add

source
fn Quantity::add(self : Quantity, other : Quantity) -> Result[Quantity, QuantityError]

#
Quantity::convert_to

source
fn Quantity::convert_to(self : Quantity, target : MeasureUnit) -> Result[Float, QuantityError]

#
Quantity::format

source
fn Quantity::format(self : Quantity, decimals : Int) -> String

#
Quantity::in_unit

source
fn Quantity::in_unit(self : Quantity, target : MeasureUnit) -> Result[Quantity, QuantityError]

#
Quantity::scale

source
fn Quantity::scale(self : Quantity, factor : Float) -> Quantity

#
Quantity::subtract

source
fn Quantity::subtract(self : Quantity, other : Quantity) -> Result[Quantity, QuantityError]

#
Quantity::validate

source
fn Quantity::validate(self : Quantity) -> Result[MeasureUnit, QuantityError]

#
QuantityError

source
pub enum QuantityError {
  IncompatibleDimensions(UnitDimension, UnitDimension)
  BelowAbsoluteZero
  InvalidValue
} derive(Eq, 
Debug)

#
ReactorCase

source
pub struct ReactorCase {
  name : String
  feed : Float
  product : Float
  byproduct : Float
  residence_time : Float
  temperature : Float
  pressure : Float
} derive(Eq, 
Debug)

#
ReactorCase::conversion

source
fn ReactorCase::conversion(self : ReactorCase) -> Float

#
ReactorCase::is_safe

source
fn ReactorCase::is_safe(self : ReactorCase, temperature_limit : Float, pressure_limit : Float) -> Bool

#
ReactorCase::product_yield

source
fn ReactorCase::product_yield(self : ReactorCase) -> Float

#
ReactorCase::selectivity

source
fn ReactorCase::selectivity(self : ReactorCase) -> Float

#
ReactorCase::space_time_yield

source
fn ReactorCase::space_time_yield(self : ReactorCase) -> Float

#
ReportBuilder

source
pub struct ReportBuilder {
  value : ChemReport
  history : Array[String]
} derive(Eq, 
Debug)

#
ReportBuilder::add_assumption

source
fn ReportBuilder::add_assumption(self : ReportBuilder, statement : String, impact : String) -> ReportBuilder

#
ReportBuilder::add_formula

source
fn ReportBuilder::add_formula(self : ReportBuilder, name : String, expression : String, explanation : String) -> ReportBuilder

#
ReportBuilder::add_input

source
fn ReportBuilder::add_input(self : ReportBuilder, name : String, value : String, unit : String?, note : String?) -> ReportBuilder

#
ReportBuilder::add_result

source
fn ReportBuilder::add_result(self : ReportBuilder, name : String, value : String, unit : String?, status : ResultStatus, note : String?) -> ReportBuilder

#
ReportBuilder::add_section

source
fn ReportBuilder::add_section(self : ReportBuilder, title : String, kind : SectionKind, body : String) -> ReportBuilder

#
ReportBuilder::add_source

source
fn ReportBuilder::add_source(self : ReportBuilder, label : String, kind : SourceKind, url : String?, license : String?, note : String?) -> ReportBuilder

#
ReportBuilder::add_warning

source
fn ReportBuilder::add_warning(self : ReportBuilder, code : String, severity : WarningSeverity, summary : String, action : String) -> ReportBuilder

#
ReportBuilder::build

source

#
ReportBuilder::events

source
fn ReportBuilder::events(self : ReportBuilder) -> Array[String]

#
ReportBuilder::is_ready

source
fn ReportBuilder::is_ready(self : ReportBuilder) -> Bool

#
ReportBuilder::quality

source
fn ReportBuilder::quality(self : ReportBuilder) -> QualityGate

#
ReportBuilder::summary

source
fn ReportBuilder::summary(self : ReportBuilder, text : String) -> ReportBuilder

#
ReportBuilder::tag

source
fn ReportBuilder::tag(self : ReportBuilder, tag : String) -> ReportBuilder

#
ReportMetadata

source
pub struct ReportMetadata {
  report_id : String
  title : String
  process_unit : String
  scenario : String
  generated_at : String
  tool_version : String
} derive(Eq, 
Debug)

#
ReportSection

source
pub struct ReportSection {
  title : String
  kind : SectionKind
  body : String
} derive(Eq, 
Debug)

#
ReportTable

source
pub struct ReportTable {
  columns : Array[String]
  rows : Array[Array[String]]
} derive(Eq, 
Debug)

#
ReportTable::column_count

source
fn ReportTable::column_count(self : ReportTable) -> Int

#
ReportTable::is_rectangular

source
fn ReportTable::is_rectangular(self : ReportTable) -> Bool

#
ReportTable::row_count

source
fn ReportTable::row_count(self : ReportTable) -> Int

#
ReportTable::to_csv

source
fn ReportTable::to_csv(self : ReportTable) -> String

#
ReportTable::to_html

source
fn ReportTable::to_html(self : ReportTable) -> String

#
ReportTable::to_markdown

source
fn ReportTable::to_markdown(self : ReportTable) -> String

#
ReportTable::validate

source
fn ReportTable::validate(self : ReportTable) -> Array[String]

#
ResultStatus

source
pub enum ResultStatus {
  Normal
  Flagged
  Estimated
} derive(Eq, 
Debug)

#
ResultValue

source
pub struct ResultValue {
  name : String
  value : String
  unit : String?
  status : ResultStatus
  note : String?
} derive(Eq, 
Debug)

#
SafetyReview

source
pub struct SafetyReview {
  name : String
  measured : Float
  design_limit : Float
  warning_fraction : Float
  unit : String
} derive(Eq, 
Debug)

#
SafetyReview::is_exceeded

source
fn SafetyReview::is_exceeded(self : SafetyReview) -> Bool

#
SafetyReview::is_warning

source
fn SafetyReview::is_warning(self : SafetyReview) -> Bool

#
SafetyReview::status

source
fn SafetyReview::status(self : SafetyReview) -> String

#
SafetyReview::utilization

source
fn SafetyReview::utilization(self : SafetyReview) -> Float

#
ScenarioPoint

source
pub struct ScenarioPoint {
  name : String
  input : Float
  output : Float
  score : Float
  status : ResultStatus
  note : String
} derive(Eq, 
Debug)

#
ScenarioPoint::efficiency

source
fn ScenarioPoint::efficiency(self : ScenarioPoint) -> Float

#
ScenarioPoint::is_acceptable

source
fn ScenarioPoint::is_acceptable(self : ScenarioPoint, minimum_score : Float) -> Bool

#
ScenarioSeries

source
pub struct ScenarioSeries {
  name : String
  points : Array[ScenarioPoint]
  input_unit : String
  output_unit : String
} derive(Eq, 
Debug)

#
ScenarioSeries::acceptable

source
fn ScenarioSeries::acceptable(self : ScenarioSeries, minimum_score : Float) -> Array[ScenarioPoint]

#
ScenarioSeries::at

source
fn ScenarioSeries::at(self : ScenarioSeries, index : Int) -> ScenarioPoint?

#
ScenarioSeries::best

source

#
ScenarioSeries::count

source
fn ScenarioSeries::count(self : ScenarioSeries) -> Int

#
ScenarioSeries::flagged

source

#
ScenarioSeries::inputs

source
fn ScenarioSeries::inputs(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::merge

source

#
ScenarioSeries::normalized

source
fn ScenarioSeries::normalized(self : ScenarioSeries) -> ScenarioSeries

#
ScenarioSeries::outputs

source
fn ScenarioSeries::outputs(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::quality_gate

source
fn ScenarioSeries::quality_gate(self : ScenarioSeries, minimum_score : Float, maximum_flagged : Int) -> Bool

#
ScenarioSeries::report_section

source
fn ScenarioSeries::report_section(self : ScenarioSeries) -> ReportSection

#
ScenarioSeries::scores

source
fn ScenarioSeries::scores(self : ScenarioSeries) -> Array[Float]

#
ScenarioSeries::summary

source

#
ScenarioSeries::to_csv

source
fn ScenarioSeries::to_csv(self : ScenarioSeries) -> String

#
ScenarioSeries::to_markdown

source
fn ScenarioSeries::to_markdown(self : ScenarioSeries) -> String

#
ScenarioSeries::to_table

source
fn ScenarioSeries::to_table(self : ScenarioSeries) -> ReportTable

#
ScenarioSeries::with_point

source
fn ScenarioSeries::with_point(self : ScenarioSeries, point : ScenarioPoint) -> ScenarioSeries

#
ScenarioSeries::worst

source

#
SectionKind

source
pub enum SectionKind {
  Context
  Method
  Safety
  Notes
} derive(Eq, 
Debug)

#
SourceKind

source
pub enum SourceKind {
  Standard
  Datasheet
  Literature
  Internal
} derive(Eq, 
Debug)

#
SourceRef

source
pub struct SourceRef {
  label : String
  kind : SourceKind
  url : String?
  license : String?
  note : String?
} derive(Eq, 
Debug)

#
Statistics

source
pub struct Statistics {
  count : Int
  minimum : Float
  maximum : Float
  mean : Float
  variance : Float
  standard_deviation : Float
  sum : Float
} derive(Eq, 
Debug)

#
StreamDirection

source
pub enum StreamDirection {
  Inlet
  Outlet
} derive(Eq, 
Debug)

#
SweepConfig

source
pub struct SweepConfig {
  start : Float
  stop : Float
  steps : Int
  label : String
} derive(Eq, 
Debug)

#
SweepConfig::is_valid

source
fn SweepConfig::is_valid(self : SweepConfig) -> Bool

#
SweepConfig::values

source
fn SweepConfig::values(self : SweepConfig) -> Array[Float]

#
UnitDimension

source
pub enum UnitDimension {
  Mass
  Amount
  Volume
  Length
  Pressure
  Energy
  Power
  Temperature
  Time
  Dimensionless
} derive(Eq, 
Debug)

#
ValidationIssue

source
pub struct ValidationIssue {
  path : String
  message : String
} derive(Eq, 
Debug)

#
WarningNote

source
pub struct WarningNote {
  code : String
  severity : WarningSeverity
  summary : String
  action : String
} derive(Eq, 
Debug)

#
WarningSeverity

source
pub enum WarningSeverity {
  Info
  Warning
  Critical
} derive(Eq, 
Debug)

#
above_control_limit

source
fn above_control_limit() -> ObservationFlag

#
annualized_energy

source
fn annualized_energy(power : Float, operating_hours : Float) -> Float

#
balance_error_percent

source
fn balance_error_percent(inlet : Float, outlet : Float) -> Float

#
balance_residual

source
fn balance_residual(inlet : Float, outlet : Float) -> Float

#
bar

source
fn bar() -> MeasureUnit

#
base_unit

source
fn base_unit(dimension : UnitDimension) -> MeasureUnit

#
batch_report

source
fn batch_report(reports : Array[ChemReport], labels : Array[String]) -> BatchReport

#
below_control_limit

source
fn below_control_limit() -> ObservationFlag

#
benchmark_exports

source
fn benchmark_exports(reports : Array[ChemReport], iterations : Int) -> BenchmarkResult

#
carbon_intensity

source
fn carbon_intensity(energy : Float, emission_factor : Float) -> Float

#
celsius

source
fn celsius() -> MeasureUnit

#
clamp

source
fn clamp(value : Float, minimum : Float, maximum : Float) -> Float

#
classify_series

source
fn classify_series(series : ScenarioSeries, lower : Float, upper : Float) -> ScenarioSeries

#
coefficient_of_variation

source
fn coefficient_of_variation(values : Array[Float]) -> Float?

#
compare_reports

source
fn compare_reports(left : ChemReport, right : ChemReport) -> Array[Diagnostic]

#
compatible

source
fn compatible(left : MeasureUnit, right : MeasureUnit) -> Bool

#
completeness_score

source
fn completeness_score(report : ChemReport) -> Float

#
component_flow

source
fn component_flow(component : String, value : Float, unit : MeasureUnit) -> ComponentFlow

#
control_limits

source
fn control_limits(values : Array[Float]) -> ControlLimits

#
diagnose_report

source
fn diagnose_report(report : ChemReport) -> DiagnosticReport

#
diagnostic

source
fn diagnostic(code : String, severity : DiagnosticSeverity, path : String, message : String, remediation : String) -> Diagnostic

#
diagnostic_report

source
fn diagnostic_report(diagnostics : Array[Diagnostic]) -> DiagnosticReport

#
distillation_case

source
fn distillation_case(feed_rate : Float, feed_fraction : Float, distillate_rate : Float, distillate_fraction : Float, bottoms_rate : Float, bottoms_fraction : Float, reflux_ratio : Float, stages : Int) -> DistillationCase

#
elasticity

source
fn elasticity(input_before : Float, input_after : Float, output_before : Float, output_after : Float) -> Float

#
energy_balance

source
fn energy_balance(streams : Array[EnergyStream]) -> EnergyBalance

#
energy_stream

source
fn energy_stream(name : String, duty : Quantity, direction : StreamDirection) -> EnergyStream

#
example_chemreport

source
fn example_chemreport() -> ChemReport

#
froude_number

source
fn froude_number(velocity : Float, length : Float, gravity : Float) -> Float

#
heat_exchanger_case

source
fn heat_exchanger_case(hot_inlet : Float, hot_outlet : Float, cold_inlet : Float, cold_outlet : Float, hot_capacity_rate : Float, cold_capacity_rate : Float, area : Float, overall_u : Float) -> HeatExchangerCase

#
inlet

source
fn inlet() -> StreamDirection

#
interpolate_linear

source
fn interpolate_linear(x : Float, x_one : Float, y_one : Float, x_two : Float, y_two : Float) -> Float

#
interpolate_scenario

source
fn interpolate_scenario(series : ScenarioSeries, input : Float) -> Float?

#
kelvin

source
fn kelvin() -> MeasureUnit

#
kg_per_hour

source
fn kg_per_hour() -> MeasureUnit

#
latent_duty

source
fn latent_duty(mass_flow : Float, latent_heat : Float, vapor_fraction : Float) -> Float

#
log_mean_temperature_difference

source
fn log_mean_temperature_difference(delta_one : Float, delta_two : Float) -> Float

#
loss_fraction

source
fn loss_fraction(inlet : Float, recovered : Float) -> Float

#
material_balance

source
fn material_balance(streams : Array[ProcessStream]) -> MaterialBalance

#
material_property

source
fn material_property(name : String, molecular_weight : Float, density : Float, heat_capacity : Float, boiling_point : Float, safety_limit : Float) -> MaterialProperty

#
mean

source
fn mean(values : Array[Float]) -> Float?

#
merge_reports

source
fn merge_reports(left : ChemReport, right : ChemReport) -> ChemReport

#
moving_average

source
fn moving_average(values : Array[Float], window : Int) -> Array[Float]

#
nearest_scenario

source
fn nearest_scenario(series : ScenarioSeries, input : Float) -> ScenarioPoint?

#
normal_observation

source
fn normal_observation() -> ObservationFlag

#
normalized_error

source
fn normalized_error(observed : Float, expected : Float) -> Float

#
outlet

source
fn outlet() -> StreamDirection

#
parse_unit

source
fn parse_unit(text : String) -> MeasureUnit?

#
pascal

source
fn pascal() -> MeasureUnit

#
percent_change

source
fn percent_change(before : Float, after : Float) -> Float

#
percentile

source
fn percentile(values : Array[Float], percentile : Float) -> Float?

#
pressure_drop_case

source
fn pressure_drop_case(length : Float, diameter : Float, velocity : Float, density : Float, viscosity : Float, roughness : Float, fittings_k : Float) -> PressureDropCase

#
pump_case

source
fn pump_case(flow_rate : Float, differential_pressure : Float, efficiency : Float, fluid_density : Float, installed_power : Float) -> PumpCase

#
quality_gate

source
fn quality_gate(report : ChemReport) -> QualityGate

#
quantity

source
fn quantity(value : Float, unit : MeasureUnit) -> Quantity

#
reactor_case

source
fn reactor_case(name : String, feed : Float, product : Float, byproduct : Float, residence_time : Float, temperature : Float, pressure : Float) -> ReactorCase

#
recovery

source
fn recovery(inlet : Float, recovered : Float) -> Float

#
regression_gate

source
fn regression_gate(baseline : ChemReport, candidate : ChemReport) -> Bool

#
report

source
fn report(metadata : ReportMetadata, summary : String, assumptions : Array[Assumption], inputs : Array[InputValue], formulas : Array[FormulaNote], results : Array[ResultValue], warnings : Array[WarningNote], sources : Array[SourceRef], sections : Array[ReportSection], tags : Array[String]) -> ChemReport

#
report_builder

source
fn report_builder(value : ChemReport) -> ReportBuilder

#
required_sections

source
fn required_sections(report : ChemReport) -> Array[String]

#
residence_time

source
fn residence_time(volume : Float, flow_rate : Float) -> Float

#
reynolds_number

source
fn reynolds_number(density : Float, velocity : Float, diameter : Float, viscosity : Float) -> Float

#
run_sweep

source
fn run_sweep(config : SweepConfig, evaluate : (Float) -> Float) -> ScenarioSeries

#
safety_factor

source
fn safety_factor(allowable : Float, applied : Float) -> Float

#
safety_review

source
fn safety_review(name : String, measured : Float, design_limit : Float, warning_fraction : Float, unit : String) -> SafetyReview

#
scenario_distance

source
fn scenario_distance(left : ScenarioPoint, right : ScenarioPoint) -> Float

#
scenario_point

source
fn scenario_point(name : String, input : Float, output : Float, score : Float, status : ResultStatus, note : String) -> ScenarioPoint

#
scenario_series

source
fn scenario_series(name : String, points : Array[ScenarioPoint], input_unit : String, output_unit : String) -> ScenarioSeries

#
scenario_status

source
fn scenario_status(score : Float, lower : Float, upper : Float) -> ResultStatus

#
sensitivity

source
fn sensitivity(base : Float, delta : Float, response_base : Float, response_delta : Float) -> Float

#
stream

source
fn stream(name : String, direction : StreamDirection, components : Array[ComponentFlow]) -> ProcessStream

#
stream_directions

source
fn stream_directions() -> Array[StreamDirection]

#
sum_negative

source
fn sum_negative(values : Array[Float]) -> Float

#
sum_positive

source
fn sum_positive(values : Array[Float]) -> Float

#
summarize

source
fn summarize(values : Array[Float]) -> Statistics

#
sweep_config

source
fn sweep_config(start : Float, stop : Float, steps : Int, label : String) -> SweepConfig

#
table

source
fn table(columns : Array[String], rows : Array[Array[String]]) -> ReportTable

#
thermal_duty

source
fn thermal_duty(mass_flow : Float, heat_capacity : Float, inlet : Float, outlet : Float) -> Float

#
total_heat_duty

source
fn total_heat_duty(sensible : Float, latent : Float, reaction : Float) -> Float

#
turnover_rate

source
fn turnover_rate(volume : Float, flow_rate : Float) -> Float

#
weighted_mean

source
fn weighted_mean(values : Array[Float], weights : Array[Float]) -> Float?

#
weighted_pressure_drop

source
fn weighted_pressure_drop(lengths : Array[Float], drops : Array[Float]) -> Float

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io