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
//! Periodic table and atomic data.
//!
//! Atomic masses are given in g/mol for elements with atomic number
//! `Z = 1..=118`, stored 1-based: `ATOMIC_MASSES[1]` is hydrogen.

/// Atomic masses (g/mol), 1-based by atomic number.
///
/// `ATOMIC_MASSES[Z]` is the atomic mass of element `Z`.
/// Index `0` is unused and set to `0.0`.
pub const ATOMIC_MASSES: [f64; 119] = [
    0.0,       // index 0 (unused)
    1.008,     // H  (1)
    4.002_602, // He (2)
    6.94,      // Li (3)
    9.012_183, // Be (4)
    10.81,     // B  (5)
    12.011,    // C  (6)
    14.007,    // N  (7)
    15.999,    // O  (8)
    18.998,    // F  (9)
    20.180,    // Ne (10)
    22.990,    // Na (11)
    24.305,    // Mg (12)
    26.982,    // Al (13)
    28.085,    // Si (14)
    30.974,    // P  (15)
    32.06,     // S  (16)
    35.45,     // Cl (17)
    39.948,    // Ar (18)
    39.098,    // K  (19)
    40.078,    // Ca (20)
    44.956,    // Sc (21)
    47.867,    // Ti (22)
    50.942,    // V  (23)
    51.996,    // Cr (24)
    54.938,    // Mn (25)
    55.845,    // Fe (26)
    58.933,    // Co (27)
    58.693,    // Ni (28)
    63.546,    // Cu (29)
    65.38,     // Zn (30)
    69.723,    // Ga (31)
    72.630,    // Ge (32)
    74.922,    // As (33)
    78.971,    // Se (34)
    79.904,    // Br (35)
    83.798,    // Kr (36)
    85.468,    // Rb (37)
    87.62,     // Sr (38)
    88.906,    // Y  (39)
    91.224,    // Zr (40)
    92.906,    // Nb (41)
    95.95,     // Mo (42)
    98.0,      // Tc (43)
    101.07,    // Ru (44)
    102.91,    // Rh (45)
    106.42,    // Pd (46)
    107.87,    // Ag (47)
    112.41,    // Cd (48)
    114.82,    // In (49)
    118.71,    // Sn (50)
    121.76,    // Sb (51)
    127.60,    // Te (52)
    126.90,    // I  (53)
    131.29,    // Xe (54)
    132.91,    // Cs (55)
    137.33,    // Ba (56)
    138.91,    // La (57)
    140.12,    // Ce (58)
    140.91,    // Pr (59)
    144.24,    // Nd (60)
    145.0,     // Pm (61)
    150.36,    // Sm (62)
    151.96,    // Eu (63)
    157.25,    // Gd (64)
    158.93,    // Tb (65)
    162.50,    // Dy (66)
    164.93,    // Ho (67)
    167.26,    // Er (68)
    168.93,    // Tm (69)
    173.05,    // Yb (70)
    174.97,    // Lu (71)
    178.49,    // Hf (72)
    180.95,    // Ta (73)
    183.84,    // W  (74)
    186.21,    // Re (75)
    190.23,    // Os (76)
    192.22,    // Ir (77)
    195.08,    // Pt (78)
    196.97,    // Au (79)
    200.59,    // Hg (80)
    204.38,    // Tl (81)
    207.2,     // Pb (82)
    208.98,    // Bi (83)
    209.0,     // Po (84)
    210.0,     // At (85)
    222.0,     // Rn (86)
    223.0,     // Fr (87)
    226.0,     // Ra (88)
    227.0,     // Ac (89)
    232.04,    // Th (90)
    231.04,    // Pa (91)
    238.03,    // U  (92)
    237.0,     // Np (93)
    244.0,     // Pu (94)
    243.0,     // Am (95)
    247.0,     // Cm (96)
    247.0,     // Bk (97)
    251.0,     // Cf (98)
    252.0,     // Es (99)
    257.0,     // Fm (100)
    258.0,     // Md (101)
    259.0,     // No (102)
    262.0,     // Lr (103)
    267.0,     // Rf (104)
    268.0,     // Db (105)
    271.0,     // Sg (106)
    272.0,     // Bh (107)
    270.0,     // Hs (108)
    277.0,     // Mt (109)
    276.0,     // Ds (110)
    281.0,     // Rg (111)
    282.0,     // Cn (112)
    285.0,     // Nh (113)
    286.0,     // Fl (114)
    289.0,     // Mc (115)
    290.0,     // Lv (116)
    293.0,     // Ts (117)
    294.0,     // Og (118)
];

/// Element symbols, 1-based by atomic number.
///
/// `SYMBOLS[Z]` is the chemical symbol of element `Z`.
pub const SYMBOLS: [&str; 119] = [
    "", "H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg", "Al", "Si", "P", "S",
    "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr", "Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge",
    "As", "Se", "Br", "Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd", "Ag", "Cd",
    "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La", "Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd",
    "Tb", "Dy", "Ho", "Er", "Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au", "Hg",
    "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th", "Pa", "U", "Np", "Pu", "Am", "Cm",
    "Bk", "Cf", "Es", "Fm", "Md", "No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn",
    "Nh", "Fl", "Mc", "Lv", "Ts", "Og",
];

/// Returns the atomic mass (g/mol) for atomic number `z` (1-based).
///
/// Returns `0.0` if `z` is out of range.
///
/// ```rust
/// use one_indexed_vec::chemistry::elements::atomic_mass;
///
/// assert!((atomic_mass(1) - 1.008).abs() < 1e-3);   // H
/// assert!((atomic_mass(6) - 12.011).abs() < 1e-3);  // C
/// assert!((atomic_mass(8) - 15.999).abs() < 1e-3);  // O
/// ```
pub fn atomic_mass(z: usize) -> f64 {
    if (1..=118).contains(&z) { ATOMIC_MASSES[z] } else { 0.0 }
}

/// Returns the chemical symbol for atomic number `z` (1-based).
///
/// Returns an empty string if `z` is out of range.
///
/// ```rust
/// use one_indexed_vec::chemistry::elements::symbol;
///
/// assert_eq!(symbol(1), "H");
/// assert_eq!(symbol(6), "C");
/// assert_eq!(symbol(8), "O");
/// ```
pub fn symbol(z: usize) -> &'static str {
    if (1..=118).contains(&z) { SYMBOLS[z] } else { "" }
}

/// Molar mass of a molecule given its formula as `(Z, count)` pairs.
///
/// The formula is a 1-based `Vec1` of `(atomic_number, count)` tuples.
///
/// ```rust
/// use one_indexed_vec::chemistry::elements::molar_mass;
/// use one_indexed_vec::vec1;
///
/// // H2O
/// let water = vec1![(1usize, 2u32), (8, 1)];
/// let m = molar_mass(&water);
/// assert!((m - 18.015).abs() < 0.01);
/// ```
pub fn molar_mass(formula: &crate::Vec1<(usize, u32)>) -> f64 {
    let mut m = 0.0;
    for i in 1..=formula.len() {
        let (z, count) = formula[i];
        m += atomic_mass(z) * count as f64;
    }
    m
}

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

    #[test]
    fn atomic_mass_h() {
        assert!((atomic_mass(1) - 1.008).abs() < 1e-3);
    }

    #[test]
    fn atomic_mass_c() {
        assert!((atomic_mass(6) - 12.011).abs() < 1e-3);
    }

    #[test]
    fn atomic_mass_o() {
        assert!((atomic_mass(8) - 15.999).abs() < 1e-3);
    }

    #[test]
    fn atomic_mass_out_of_range() {
        assert_eq!(atomic_mass(0), 0.0);
        assert_eq!(atomic_mass(200), 0.0);
    }

    #[test]
    fn symbols() {
        assert_eq!(symbol(1), "H");
        assert_eq!(symbol(6), "C");
        assert_eq!(symbol(8), "O");
        assert_eq!(symbol(79), "Au");
        assert_eq!(symbol(0), "");
    }

    #[test]
    fn molar_mass_water() {
        let water = vec1![(1usize, 2u32), (8, 1)];
        let m = molar_mass(&water);
        assert!((m - 18.015).abs() < 0.01);
    }

    #[test]
    fn molar_mass_co2() {
        let co2 = vec1![(6usize, 1u32), (8, 2)];
        let m = molar_mass(&co2);
        assert!((m - 44.009).abs() < 0.01);
    }
}