#![forbid(unsafe_code)]
#![warn(missing_docs)]
use std::error::Error;
use std::fmt;
pub const MOLAR_GAS_CONSTANT: f64 = 8.314_462_618_153_24;
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Pressure(f64);
impl Pressure {
pub fn pascals(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "absolute pressure")?;
Ok(Self(value))
}
pub fn kilopascals(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "absolute pressure")?;
let pascals = value * 1_000.0;
ensure_finite(pascals)?;
Ok(Self(pascals))
}
pub const fn as_pascals(self) -> f64 {
self.0
}
pub fn as_kilopascals(self) -> f64 {
self.0 / 1_000.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Volume(f64);
impl Volume {
pub fn cubic_meters(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "volume")?;
Ok(Self(value))
}
pub fn liters(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "volume")?;
Ok(Self(value / 1_000.0))
}
pub const fn as_cubic_meters(self) -> f64 {
self.0
}
pub fn as_liters(self) -> f64 {
self.0 * 1_000.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Temperature(f64);
impl Temperature {
pub fn kelvin(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "absolute temperature")?;
Ok(Self(value))
}
pub fn celsius(value: f64) -> Result<Self, GasError> {
if !value.is_finite() {
return Err(GasError::NonFinite("temperature"));
}
let kelvin = value + 273.15;
validate_positive_finite(kelvin, "absolute temperature")?;
Ok(Self(kelvin))
}
pub const fn as_kelvin(self) -> f64 {
self.0
}
pub fn as_celsius(self) -> f64 {
self.0 - 273.15
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct Amount(f64);
impl Amount {
pub fn moles(value: f64) -> Result<Self, GasError> {
validate_positive_finite(value, "amount")?;
Ok(Self(value))
}
pub const fn as_moles(self) -> f64 {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
pub struct VolumetricFlow(f64);
impl VolumetricFlow {
pub fn cubic_meters_per_second(value: f64) -> Result<Self, GasError> {
validate_non_negative_finite(value, "volumetric flow")?;
Ok(Self(value))
}
pub const fn as_cubic_meters_per_second(self) -> f64 {
self.0
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GasCondition {
pressure: Pressure,
temperature: Temperature,
}
impl GasCondition {
pub const fn new(pressure: Pressure, temperature: Temperature) -> Self {
Self {
pressure,
temperature,
}
}
pub const fn pressure(self) -> Pressure {
self.pressure
}
pub const fn temperature(self) -> Temperature {
self.temperature
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct IdealGasState {
pressure: Pressure,
volume: Volume,
temperature: Temperature,
amount: Amount,
}
impl IdealGasState {
pub fn from_pressure_volume_temperature(
pressure: Pressure,
volume: Volume,
temperature: Temperature,
) -> Result<Self, GasError> {
let amount = Amount(checked(
pressure.0 * volume.0 / (MOLAR_GAS_CONSTANT * temperature.0),
)?);
Ok(Self {
pressure,
volume,
temperature,
amount,
})
}
pub fn from_amount_volume_temperature(
amount: Amount,
volume: Volume,
temperature: Temperature,
) -> Result<Self, GasError> {
let pressure = Pressure(checked(
amount.0 * MOLAR_GAS_CONSTANT * temperature.0 / volume.0,
)?);
Ok(Self {
pressure,
volume,
temperature,
amount,
})
}
pub fn from_pressure_amount_temperature(
pressure: Pressure,
amount: Amount,
temperature: Temperature,
) -> Result<Self, GasError> {
let volume = Volume(checked(
amount.0 * MOLAR_GAS_CONSTANT * temperature.0 / pressure.0,
)?);
Ok(Self {
pressure,
volume,
temperature,
amount,
})
}
pub fn from_pressure_volume_amount(
pressure: Pressure,
volume: Volume,
amount: Amount,
) -> Result<Self, GasError> {
let temperature = Temperature(checked(
pressure.0 * volume.0 / (amount.0 * MOLAR_GAS_CONSTANT),
)?);
Ok(Self {
pressure,
volume,
temperature,
amount,
})
}
pub const fn pressure(self) -> Pressure {
self.pressure
}
pub const fn volume(self) -> Volume {
self.volume
}
pub const fn temperature(self) -> Temperature {
self.temperature
}
pub const fn amount(self) -> Amount {
self.amount
}
}
pub fn convert_volume(
volume: Volume,
from: GasCondition,
to: GasCondition,
) -> Result<Volume, GasError> {
let converted =
volume.0 * from.pressure.0 / to.pressure.0 * to.temperature.0 / from.temperature.0;
Ok(Volume(checked(converted)?))
}
pub fn convert_flow(
flow: VolumetricFlow,
from: GasCondition,
to: GasCondition,
) -> Result<VolumetricFlow, GasError> {
let converted =
flow.0 * from.pressure.0 / to.pressure.0 * to.temperature.0 / from.temperature.0;
ensure_finite(converted)?;
Ok(VolumetricFlow(converted))
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum GasError {
NonFinite(&'static str),
Negative(&'static str),
Zero(&'static str),
CalculationOutOfRange,
}
impl fmt::Display for GasError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::NonFinite(name) => write!(formatter, "{name} must be finite"),
Self::Negative(name) => write!(formatter, "{name} must not be negative"),
Self::Zero(name) => write!(formatter, "{name} must be greater than zero"),
Self::CalculationOutOfRange => {
formatter.write_str("calculation produced an out-of-range result")
}
}
}
}
impl Error for GasError {}
fn validate_non_negative_finite(value: f64, name: &'static str) -> Result<(), GasError> {
if !value.is_finite() {
return Err(GasError::NonFinite(name));
}
if value < 0.0 {
return Err(GasError::Negative(name));
}
Ok(())
}
fn validate_positive_finite(value: f64, name: &'static str) -> Result<(), GasError> {
validate_non_negative_finite(value, name)?;
if value == 0.0 {
return Err(GasError::Zero(name));
}
Ok(())
}
fn ensure_finite(value: f64) -> Result<(), GasError> {
if value.is_finite() {
Ok(())
} else {
Err(GasError::CalculationOutOfRange)
}
}
fn checked(value: f64) -> Result<f64, GasError> {
if value.is_finite() && value > 0.0 {
Ok(value)
} else {
Err(GasError::CalculationOutOfRange)
}
}
#[cfg(test)]
mod tests {
use super::*;
fn pressure(value: f64) -> Pressure {
Pressure::pascals(value).unwrap()
}
fn volume(value: f64) -> Volume {
Volume::cubic_meters(value).unwrap()
}
fn temperature(value: f64) -> Temperature {
Temperature::kelvin(value).unwrap()
}
#[test]
fn derives_each_ideal_gas_variable() {
let p = pressure(100_000.0);
let t = temperature(300.0);
let n = Amount::moles(1.0).unwrap();
let v = volume(MOLAR_GAS_CONSTANT * 300.0 / 100_000.0);
let by_amount = IdealGasState::from_pressure_volume_temperature(p, v, t).unwrap();
let by_pressure = IdealGasState::from_amount_volume_temperature(n, v, t).unwrap();
let by_volume = IdealGasState::from_pressure_amount_temperature(p, n, t).unwrap();
let by_temperature = IdealGasState::from_pressure_volume_amount(p, v, n).unwrap();
assert!((by_amount.amount().0 - 1.0).abs() < 1e-12);
assert!((by_pressure.pressure().0 - p.0).abs() < 1e-9);
assert!((by_volume.volume().0 - v.0).abs() < 1e-15);
assert!((by_temperature.temperature().0 - t.0).abs() < 1e-12);
}
#[test]
fn pressure_conversion_is_explicit() {
let pressure = Pressure::kilopascals(101.325).unwrap();
assert!((pressure.as_pascals() - 101_325.0).abs() < 1e-10);
assert_eq!(pressure.as_kilopascals(), 101.325);
}
#[test]
fn celsius_is_stored_as_kelvin() {
let temperature = Temperature::celsius(26.85).unwrap();
assert!((temperature.as_kelvin() - 300.0).abs() < 1e-12);
assert!((temperature.as_celsius() - 26.85).abs() < 1e-12);
}
#[test]
fn pressure_change_converts_volume() {
let from = GasCondition::new(pressure(100_000.0), temperature(300.0));
let to = GasCondition::new(pressure(200_000.0), temperature(300.0));
let converted = convert_volume(volume(1.0), from, to).unwrap();
assert!((converted.0 - 0.5).abs() < 1e-12);
}
#[test]
fn temperature_change_converts_flow() {
let from = GasCondition::new(pressure(100_000.0), temperature(300.0));
let to = GasCondition::new(pressure(100_000.0), temperature(600.0));
let flow = VolumetricFlow::cubic_meters_per_second(0.25).unwrap();
let converted = convert_flow(flow, from, to).unwrap();
assert!((converted.0 - 0.5).abs() < 1e-12);
}
#[test]
fn zero_flow_remains_zero() {
let condition = GasCondition::new(pressure(100_000.0), temperature(300.0));
let flow = VolumetricFlow::cubic_meters_per_second(0.0).unwrap();
assert_eq!(convert_flow(flow, condition, condition).unwrap().0, 0.0);
}
#[test]
fn invalid_quantities_are_rejected() {
assert_eq!(
Pressure::pascals(0.0),
Err(GasError::Zero("absolute pressure"))
);
assert_eq!(Volume::liters(-1.0), Err(GasError::Negative("volume")));
assert_eq!(
Temperature::kelvin(f64::NAN),
Err(GasError::NonFinite("absolute temperature"))
);
assert_eq!(
Temperature::celsius(-273.15),
Err(GasError::Zero("absolute temperature"))
);
assert_eq!(Amount::moles(0.0), Err(GasError::Zero("amount")));
}
#[test]
fn calculation_overflow_is_reported() {
let result = IdealGasState::from_amount_volume_temperature(
Amount::moles(f64::MAX).unwrap(),
volume(f64::MIN_POSITIVE),
temperature(300.0),
);
assert_eq!(result, Err(GasError::CalculationOutOfRange));
}
}