one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! Chemical thermodynamics.

use crate::Vec1;

/// Universal gas constant R in J/(mol*K).
pub const R_GAS: f64 = 8.314_462_618_153_24;

impl Vec1<f64> {
    /// Ideal gas pressure: `P = n R T / V`.
    ///
    /// `self` holds temperatures `T` in Kelvin.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let t: Vec1<f64> = vec1![273.15, 300.0, 350.0];
    /// let p = t.ideal_gas_pressure(1.0, 22.4e-3);
    /// assert!(p[1] > 0.0);
    /// ```
    pub fn ideal_gas_pressure(&self, moles: f64, volume: f64) -> Vec1<f64> {
        assert!(volume > 0.0, "ideal_gas_pressure: volume must be > 0");
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            out.push(moles * R_GAS * self[i] / volume);
        }
        out
    }

    /// Gibbs free energy: `dG = dH - T * dS`.
    ///
    /// `self` holds temperatures `T` in Kelvin.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let t: Vec1<f64> = vec1![298.15, 350.0, 400.0];
    /// let g = t.gibbs_free_energy(-100.0, -0.2);
    /// // dG = dH - T*dS, with dS < 0 -> dG increases with T
    /// assert!(g[1] < g[2]);
    /// assert!(g[2] < g[3]);
    /// ```
    pub fn gibbs_free_energy(&self, delta_h: f64, delta_s: f64) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            out.push(delta_h - self[i] * delta_s);
        }
        out
    }

    /// Equilibrium constant from Gibbs free energy:
    /// `K = exp(-dG / (R T))`.
    ///
    /// `self` holds temperatures `T` in Kelvin.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let t: Vec1<f64> = vec1![298.15, 350.0];
    /// let k = t.equilibrium_constant(-10000.0);
    /// assert!(k[1] > 0.0);
    /// ```
    pub fn equilibrium_constant(&self, delta_g: f64) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let t = self[i];
            assert!(t > 0.0, "equilibrium_constant: T must be > 0");
            out.push(libm::exp(-delta_g / (R_GAS * t)));
        }
        out
    }

    /// `pH = -log10[H+]`.
    ///
    /// `self` holds hydrogen ion concentrations in mol/L.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let h: Vec1<f64> = vec1![1e-7, 1e-3, 1.0];
    /// let p = h.ph();
    /// assert!((p[1] - 7.0).abs() < 1e-10);
    /// assert!((p[2] - 3.0).abs() < 1e-10);
    /// assert!((p[3] - 0.0).abs() < 1e-10);
    /// ```
    pub fn ph(&self) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let c = self[i];
            assert!(c > 0.0, "ph: concentration must be > 0");
            out.push(-libm::log10(c));
        }
        out
    }

    /// `pOH = -log10[OH-]`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let oh: Vec1<f64> = vec1![1e-7];
    /// let p = oh.poh();
    /// assert!((p[1] - 7.0).abs() < 1e-10);
    /// ```
    pub fn poh(&self) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let c = self[i];
            assert!(c > 0.0, "poh: concentration must be > 0");
            out.push(-libm::log10(c));
        }
        out
    }

    /// Beer-Lambert absorbance `A = epsilon * c * l`.
    ///
    /// `self` holds concentrations `c` in mol/L.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let c: Vec1<f64> = vec1![0.001, 0.01, 0.1];
    /// let a = c.beer_lambert(15000.0, 1.0);
    /// assert!(a[1] > 0.0);
    /// assert!(a[2] > a[1]);
    /// ```
    pub fn beer_lambert(&self, epsilon: f64, path_length: f64) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            out.push(epsilon * self[i] * path_length);
        }
        out
    }
}

#[cfg(test)]
mod tests {
    use crate::vec1;

    #[test]
    fn ideal_gas_pressure_basic() {
        let t = vec1![273.15f64];
        let p = t.ideal_gas_pressure(1.0, 22.4e-3);
        // ~101 kPa
        assert!((p[1] / 1000.0 - 101.3).abs() < 0.5);
    }

    #[test]
    fn gibbs_free_energy_basic() {
        let t = vec1![298.15f64, 350.0, 400.0];
        let g = t.gibbs_free_energy(-100.0, -0.2);
        assert!(g[1] < g[2]);
        assert!(g[2] < g[3]);
    }

    #[test]
    fn equilibrium_constant_basic() {
        let t = vec1![298.15f64, 350.0];
        let k = t.equilibrium_constant(-10000.0);
        assert!(k[1] > 0.0);
        assert!(k[2] > 0.0);
    }

    #[test]
    fn ph_basic() {
        let h = vec1![1e-7, 1e-3, 1.0];
        let p = h.ph();
        assert!((p[1] - 7.0).abs() < 1e-10);
        assert!((p[2] - 3.0).abs() < 1e-10);
        assert!((p[3] - 0.0).abs() < 1e-10);
    }

    #[test]
    fn poh_basic() {
        let oh = vec1![1e-7];
        let p = oh.poh();
        assert!((p[1] - 7.0).abs() < 1e-10);
    }

    #[test]
    fn beer_lambert_basic() {
        let c = vec1![0.001, 0.01, 0.1];
        let a = c.beer_lambert(15000.0, 1.0);
        assert!(a[1] > 0.0);
        assert!(a[2] > a[1]);
        assert!(a[3] > a[2]);
    }
}