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
//! Quantum mechanics: energy levels and wave functions.

use crate::Vec1;

/// Reduced Planck constant hbar in J*s.
pub const HBAR: f64 = 1.054_571_817e-34;

/// Electron mass in kg.
pub const M_E: f64 = 9.109_383_701_5e-31;

/// Boltzmann constant in J/K.
pub const K_B: f64 = 1.380_649e-23;

impl Vec1<f64> {
    /// Energies of a particle in a 1-D infinite square well.
    ///
    /// `E_n = n^2 * pi^2 * hbar^2 / (2 m L^2)`, `n = 1, 2, 3, ...`
    ///
    /// `self` holds the quantum numbers `n`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let n: Vec1<f64> = vec1![1.0, 2.0, 3.0];
    /// let e = n.infinite_well_energies(1e-9, 9.11e-31);
    /// assert!(e[1] > 0.0);
    /// assert!((e[2] / e[1] - 4.0).abs() < 1e-10);
    /// ```
    pub fn infinite_well_energies(&self, length: f64, mass: f64) -> Vec1<f64> {
        assert!(length > 0.0, "infinite_well_energies: length must be > 0");
        assert!(mass > 0.0, "infinite_well_energies: mass must be > 0");
        let factor = core::f64::consts::PI.powi(2) * HBAR * HBAR / (2.0 * mass * length * length);
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            out.push(self[i] * self[i] * factor);
        }
        out
    }

    /// Hydrogen-like energy levels (Bohr model, in eV).
    ///
    /// `E_n = -13.6 eV / n^2`, `n = 1, 2, 3, ...`
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let n: Vec1<f64> = vec1![1.0, 2.0, 3.0];
    /// let e = n.hydrogen_energies();
    /// assert!((e[1] - (-13.6)).abs() < 1e-10);
    /// assert!((e[2] - (-3.4)).abs() < 1e-10);
    /// ```
    pub fn hydrogen_energies(&self) -> Vec1<f64> {
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let n = self[i];
            out.push(-13.6 / (n * n));
        }
        out
    }

    /// Harmonic oscillator energies (1-D).
    ///
    /// `E_n = (n + 1/2) * hbar * omega`
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let n: Vec1<f64> = vec1![0.0, 1.0, 2.0];
    /// let e = n.harmonic_oscillator_energies(1.0);
    /// assert!(e[1] > 0.0);
    /// ```
    pub fn harmonic_oscillator_energies(&self, omega: f64) -> Vec1<f64> {
        assert!(omega > 0.0, "harmonic_oscillator_energies: omega must be > 0");
        let factor = HBAR * omega;
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            out.push((self[i] + 0.5) * factor);
        }
        out
    }

    /// Wavelengths of the hydrogen Balmer series.
    ///
    /// `1/lambda = R * (1/n1^2 - 1/n2^2)`, `n2 > n1`.
    ///
    /// `self` holds the lower quantum numbers `n1`.
    ///
    /// ```rust
    /// use one_indexed_vec::{vec1, Vec1};
    ///
    /// let n1: Vec1<f64> = vec1![2.0];
    /// let wl = n1.balmer_wavelengths(3.0);
    /// // Balmer-alpha (H-alpha) ~ 656.3 nm
    /// assert!((wl[1] * 1e9 - 656.3).abs() < 1.0);
    /// ```
    pub fn balmer_wavelengths(&self, n2: f64) -> Vec1<f64> {
        const RYDBERG: f64 = 1.097_373_156_8e7; // m^-1
        assert!(n2 > 0.0, "balmer_wavelengths: n2 must be > 0");
        let mut out = Vec1::with_capacity(self.len());
        for i in 1..=self.len() {
            let n1 = self[i];
            assert!(n2 > n1, "balmer_wavelengths: n2 ({n2}) must be > n1 ({n1})");
            let inv_lambda = RYDBERG * (1.0 / (n1 * n1) - 1.0 / (n2 * n2));
            out.push(1.0 / inv_lambda);
        }
        out
    }
}

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

    #[test]
    fn infinite_well_ratios() {
        let n = vec1![1.0f64, 2.0, 3.0];
        let e = n.infinite_well_energies(1e-9, 9.109_383_701_5e-31);
        assert!((e[2] / e[1] - 4.0).abs() < 1e-10);
        assert!((e[3] / e[1] - 9.0).abs() < 1e-10);
    }

    #[test]
    fn hydrogen_levels() {
        let n = vec1![1.0f64, 2.0, 3.0];
        let e = n.hydrogen_energies();
        assert!((e[1] - (-13.6)).abs() < 1e-10);
        assert!((e[2] - (-3.4)).abs() < 1e-10);
    }

    #[test]
    fn harmonic_oscillator_ground_state() {
        let n = vec1![0.0f64];
        let e = n.harmonic_oscillator_energies(1.0);
        assert!((e[1] - 0.5 * 1.054_571_817e-34).abs() < 1e-50);
    }

    #[test]
    fn balmer_alpha() {
        let n1 = vec1![2.0f64];
        let wl = n1.balmer_wavelengths(3.0);
        assert!((wl[1] * 1e9 - 656.3).abs() < 1.0);
    }

    #[test]
    #[should_panic(expected = "n2")]
    fn balmer_invalid_n2() {
        let n1 = vec1![3.0f64];
        let _ = n1.balmer_wavelengths(2.0);
    }
}