Struct Compound 

pub struct Compound {
    pub elements: Vec<Element>,
    pub coefficient: usize,
    pub state: Option<State>,
    pub concentration: f32,
}

An inidiviual compound. Containing some elements and a coefficient.

Eg: 2Fe2O3

Fields

elements: Vec<Element>

The elements of a compound

coefficient: usize

The coefficient of the whole compound

state: Option<State>

The state of the compound

concentration: f32

The concentration in M (mol/L) of the compound

Implementations

impl Compound

pub fn get_units(&self, volume: f32) -> f64

Get the formula units, atoms or molecules of a compound

Examples

use chem_eq::{Equation, AVAGADRO_CONSTANT};

let mut eq = Equation::new("H2 + O2 -> H2O").unwrap();
eq.set_concentration_by_name("H2", 1.0).unwrap();
eq.set_volume(1.0);
let cmp = eq.iter_compounds().next().unwrap();
assert_eq!(cmp.get_units(eq.volume().unwrap()), AVAGADRO_CONSTANT);

pub fn parse(input: &str) -> Result<Self, CompoundError>

Parse a compound from str

Examples

use chem_eq::{Compound, error::CompoundError};

let cmp = Compound::parse("Fe2O3");
assert!(cmp.is_ok());

let cmp = Compound::parse("Fe2O3 + O2");
assert_eq!(cmp.unwrap_err(), CompoundError::TooMuchInput(" + O2".to_string()));

pub fn add_unit(&mut self, volume: f32, addend: isize)

Add to the formula units, atoms or molecules of a compound

Examples

use chem_eq::{Equation, AVAGADRO_CONSTANT};

let mut eq = Equation::new("H2 + O2 -> H2O").unwrap();
eq.set_concentration_by_name("H2", 1.0).unwrap();
eq.set_volume(1.0);
let volume = eq.volume().unwrap();
let cmp = eq.get_compound_by_name_mut("H2").unwrap();
cmp.add_unit(volume, 1);
assert_eq!(cmp.get_units(volume), AVAGADRO_CONSTANT + 1.0);

Trait Implementations

impl Clone for Compound

fn clone(&self) -> Compound

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Compound

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Compound

fn default() -> Compound

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Compound

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Compound

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Compound

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Compound

fn partial_cmp(&self, other: &Compound) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Compound

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.