molecular-formulas 0.1.9

A Rust crate for parsing, manipulating, and analyzing molecular formulas.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

//! Submodule providing a struct and implementation of the `ExtensionTree` trait
//! for molecular formulas that can contain isotopes such as `[13C]`.

use elements_rs::{BondsNumber, Element, ElementVariant, Isotope, RelativeAtomicMass};

use crate::{ChargedMolecularTree, MolecularTree};

impl<Count> MolecularTree<Count> for Isotope {
    type ElementIter<'a>
        = core::iter::Once<Element>
    where
        Self: 'a;

    type NonHydrogenElementIter<'a>
        = core::iter::Filter<core::iter::Once<Element>, fn(&Element) -> bool>
    where
        Self: 'a;

    #[inline]
    fn elements(&self) -> Self::ElementIter<'_> {
        core::iter::once(self.element())
    }

    #[inline]
    fn non_hydrogens(&self) -> Self::NonHydrogenElementIter<'_> {
        core::iter::once(self.element()).filter(|&e| e != Element::H)
    }

    #[inline]
    fn contains_elements(&self) -> bool {
        true
    }

    #[inline]
    fn contains_non_hydrogens(&self) -> bool {
        self.element() != Element::H
    }

    #[inline]
    fn contains_isotopes(&self) -> bool {
        true
    }

    #[inline]
    fn contains_element(&self, element: Element) -> bool {
        self.element() == element
    }

    #[inline]
    fn contains_isotope(&self, isotope: elements_rs::Isotope) -> bool {
        *self == isotope
    }

    #[inline]
    fn number_of_elements(&self) -> usize {
        1
    }

    #[inline]
    fn count_of_element<C>(&self, element: Element) -> Result<C, crate::errors::CountError>
    where
        C: From<Count>
            + num_traits::CheckedAdd
            + num_traits::CheckedMul
            + num_traits::ConstZero
            + num_traits::ConstOne,
    {
        Ok(if self.element() == element { C::ONE } else { C::ZERO })
    }

    #[inline]
    fn count_of_isotope<C>(&self, isotope: Isotope) -> Result<C, crate::errors::CountError>
    where
        C: From<Count>
            + num_traits::CheckedAdd
            + num_traits::CheckedMul
            + num_traits::ConstZero
            + num_traits::ConstOne,
    {
        Ok(if *self == isotope { C::ONE } else { C::ZERO })
    }

    fn isotopologue_mass(&self) -> f64 {
        self.relative_atomic_mass()
    }

    #[inline]
    fn is_noble_gas_compound(&self) -> bool {
        self.is_noble_gas()
    }

    fn isotopic_normalization(&self) -> Self {
        *self
    }

    fn check_hill_ordering(
        &self,
        predecessor: Option<Element>,
        has_carbon: bool,
    ) -> Result<Option<Element>, ()> {
        let element = self.element();
        if let Some(prev) = predecessor
            && !crate::molecular_tree::is_hill_sorted_pair(prev, element, has_carbon)
        {
            return Err(());
        }
        Ok(Some(element))
    }
}

impl<Count, Charge> ChargedMolecularTree<Count, Charge> for Isotope {
    fn charge(&self) -> f64 {
        0.0
    }

    fn isotopologue_mass_with_charge(&self) -> f64 {
        self.relative_atomic_mass()
    }

    fn molar_mass(&self) -> f64 {
        self.element().standard_atomic_weight()
    }
}