dimensioned/opt/rustwide/target/x86_64-unknown-linux-gnu/debug/build/dimensioned-7f44ed1ff556b03d/out/

cgs.rs

/**
The Gaussian CGS unit system

Note: this system is incomplete. More derived units and constants are coming.





Following, we list all of the [base units](#base-units), [derived units](#derived-units), and
[constants](#constants) that are defined in this unit system.
# Base Units
Constant | Unit | Print Token | Dimension
---|---|---|---
SQRTCM | SqrtCentimeter | sqrtcm | 
SQRTG | SqrtGram | sqrtg | 
S | Second | s | Time
# Derived Units
Constant | Unit | Unit Definition | Dimension
---|---|---|---
CM | Centimeter | SqrtCentimeter * SqrtCentimeter | Length
G | Gram | SqrtGram * SqrtGram | Mass
CM2 | Centimeter2 | Centimeter * Centimeter | Area
CM3 | Centimeter3 | Centimeter2 * Centimeter | Volume
S2 | Second2 | Second * Second | 
S3 | Second3 | Second2 * Second | 
S4 | Second4 | Second3 * Second | 
CMPS | CentimeterPerSecond | Centimeter / Second | Velocity
CMPS3 | CentimeterPerSecond3 | Centimeter / Second3 | Jerk
CMPS4 | CentimeterPerSecond4 | Centimeter / Second4 | 
CM2PS | Centimeter2PerSecond | Centimeter2 / Second | 
CM2PS2 | Centimeter2PerSecond2 | Centimeter2 / Second2 | 
CM2PS3 | Centimeter2PerSecond3 | Centimeter2 / Second3 | 
CM3PS | Centimeter3PerSecond | Centimeter3 / Second | 
CM3PS2 | Centimeter3PerSecond2 | Centimeter3 / Second2 | 
CM3PS3 | Centimeter3PerSecond3 | Centimeter3 / Second3 | 
GAL | Gal | Centimeter / Second2 | Acceleration
DYN | Dyne | Gram * Gal | Force
ERG | Erg | Dyne * Centimeter | Energy
ERGPS | ErgPerSecond | Erg / Second | Power
BA | Barye | Dyne / Centimeter2 | Pressure
P | Poise | Gram / Centimeter / Second | 
ST | Stokes | Centimeter2 / Second | 
K | Kayser | Unitless / Centimeter | ReciprocalLength
STATC | StatCoulomb | SqrtGram * SqrtCentimeter * Centimeter / Second | 
STATA | StatAmpere | StatCoulomb / Second | 
STATV | StatVolt | Erg / StatCoulomb | 
# Constants
Name | Constant | Value | Unit | Dimension
---|---|---|---|---
Meter | M | HECTO * CM | Centimeter | Length
|
*/
pub mod cgs {
    #![allow(clippy::upper_case_acronyms)]
    make_units! {
        CGS;
        ONE: Unitless;

        base {
            SQRTCM: SqrtCentimeter, "sqrtcm";
            SQRTG: SqrtGram, "sqrtg";
            S: Second, "s", Time;
        }

        derived {
            CM: Centimeter = (SqrtCentimeter * SqrtCentimeter), Length;
            G: Gram = (SqrtGram * SqrtGram), Mass;
            CM2: Centimeter2 = (Centimeter * Centimeter), Area;
            CM3: Centimeter3 = (Centimeter2 * Centimeter), Volume;
            S2: Second2 = (Second * Second);
            S3: Second3 = (Second2 * Second);
            S4: Second4 = (Second3 * Second);
            CMPS: CentimeterPerSecond = (Centimeter / Second), Velocity;
            CMPS3: CentimeterPerSecond3 = (Centimeter / Second3), Jerk;
            CMPS4: CentimeterPerSecond4 = (Centimeter / Second4);
            CM2PS: Centimeter2PerSecond = (Centimeter2 / Second);
            CM2PS2: Centimeter2PerSecond2 = (Centimeter2 / Second2);
            CM2PS3: Centimeter2PerSecond3 = (Centimeter2 / Second3);
            CM3PS: Centimeter3PerSecond = (Centimeter3 / Second);
            CM3PS2: Centimeter3PerSecond2 = (Centimeter3 / Second2);
            CM3PS3: Centimeter3PerSecond3 = (Centimeter3 / Second3);
            GAL: Gal = (Centimeter / Second2), Acceleration;
            DYN: Dyne = (Gram * Gal), Force;
            ERG: Erg = (Dyne * Centimeter), Energy;
            ERGPS: ErgPerSecond = (Erg / Second), Power;
            BA: Barye = (Dyne / Centimeter2), Pressure;
            P: Poise = (Gram / Centimeter / Second);
            ST: Stokes = (Centimeter2 / Second);
            K: Kayser = (Unitless / Centimeter), ReciprocalLength;
            STATC: StatCoulomb = (SqrtGram * SqrtCentimeter * Centimeter / Second);
            STATA: StatAmpere = (StatCoulomb / Second);
            STATV: StatVolt = (Erg / StatCoulomb);
        }

        constants {
            M: Centimeter = HECTO * CM.value_unsafe;
        }

        fmt = false;
    }

    #[cfg(feature = "serde")]
    impl_serde!(CGS);
    #[cfg(feature = "clapme")]
    impl_clapme!(CGS);
    #[cfg(feature = "auto-args")]
    impl_auto_args!(CGS);

    #[cfg(feature = "rand")]
    impl_rand!(CGS);

    pub use self::f64consts::*;


    #[test]
    fn test_cgs_constants() {
        #[allow(unused_imports)]
        use crate::f64prefixes::*;
        #[allow(unused_imports)]
        use core::f64::consts;

        assert_eq!(M, HECTO * CM);
    }
    /// Test that serializing/deserializing values with units is
    /// equivalent to doing so with raw numeric types.
    #[cfg(feature = "serde")]
    #[test]
    fn test_cgs_serde() {
        use ::serde_test::{assert_tokens, Token};

        let value = 1.0 * SQRTCM;
        assert_tokens(&value, &[Token::F64(1.0)]);

        let value = 1.0 * SQRTG;
        assert_tokens(&value, &[Token::F64(1.0)]);

        let value = 1.0 * S;
        assert_tokens(&value, &[Token::F64(1.0)]);

    }
    /// Test that we can get random numbers nicely.
    #[cfg(feature = "rand")]
    #[test]
    fn test_cgs_rand() {
        use ::rand::prelude::*;
        use ::rand::rngs::{StdRng};
        use ::rand::distributions::Uniform;
        use ::rand::{SeedableRng};
        let mut rng1 = StdRng::from_seed([0u8;32]);
        let mut rng2 = rng1.clone();

        let raw_value: f64 = rng1.gen();
        let value: SqrtCentimeter<f64>  = rng2.gen();
        assert_eq!(value, SqrtCentimeter::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: SqrtGram<f64>  = rng2.gen();
        assert_eq!(value, SqrtGram::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Second<f64>  = rng2.gen();
        assert_eq!(value, Second::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter<f64>  = rng2.gen();
        assert_eq!(value, Centimeter::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter::new(-5.0), Centimeter::new(7.0)));
        assert_eq!(value, Centimeter::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Gram<f64>  = rng2.gen();
        assert_eq!(value, Gram::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Gram::new(-5.0), Gram::new(7.0)));
        assert_eq!(value, Gram::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter2<f64>  = rng2.gen();
        assert_eq!(value, Centimeter2::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter2::new(-5.0), Centimeter2::new(7.0)));
        assert_eq!(value, Centimeter2::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter3<f64>  = rng2.gen();
        assert_eq!(value, Centimeter3::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter3::new(-5.0), Centimeter3::new(7.0)));
        assert_eq!(value, Centimeter3::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Second2<f64>  = rng2.gen();
        assert_eq!(value, Second2::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Second2::new(-5.0), Second2::new(7.0)));
        assert_eq!(value, Second2::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Second3<f64>  = rng2.gen();
        assert_eq!(value, Second3::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Second3::new(-5.0), Second3::new(7.0)));
        assert_eq!(value, Second3::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Second4<f64>  = rng2.gen();
        assert_eq!(value, Second4::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Second4::new(-5.0), Second4::new(7.0)));
        assert_eq!(value, Second4::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: CentimeterPerSecond<f64>  = rng2.gen();
        assert_eq!(value, CentimeterPerSecond::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(CentimeterPerSecond::new(-5.0), CentimeterPerSecond::new(7.0)));
        assert_eq!(value, CentimeterPerSecond::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: CentimeterPerSecond3<f64>  = rng2.gen();
        assert_eq!(value, CentimeterPerSecond3::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(CentimeterPerSecond3::new(-5.0), CentimeterPerSecond3::new(7.0)));
        assert_eq!(value, CentimeterPerSecond3::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: CentimeterPerSecond4<f64>  = rng2.gen();
        assert_eq!(value, CentimeterPerSecond4::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(CentimeterPerSecond4::new(-5.0), CentimeterPerSecond4::new(7.0)));
        assert_eq!(value, CentimeterPerSecond4::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter2PerSecond<f64>  = rng2.gen();
        assert_eq!(value, Centimeter2PerSecond::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter2PerSecond::new(-5.0), Centimeter2PerSecond::new(7.0)));
        assert_eq!(value, Centimeter2PerSecond::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter2PerSecond2<f64>  = rng2.gen();
        assert_eq!(value, Centimeter2PerSecond2::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter2PerSecond2::new(-5.0), Centimeter2PerSecond2::new(7.0)));
        assert_eq!(value, Centimeter2PerSecond2::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter2PerSecond3<f64>  = rng2.gen();
        assert_eq!(value, Centimeter2PerSecond3::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter2PerSecond3::new(-5.0), Centimeter2PerSecond3::new(7.0)));
        assert_eq!(value, Centimeter2PerSecond3::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter3PerSecond<f64>  = rng2.gen();
        assert_eq!(value, Centimeter3PerSecond::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter3PerSecond::new(-5.0), Centimeter3PerSecond::new(7.0)));
        assert_eq!(value, Centimeter3PerSecond::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter3PerSecond2<f64>  = rng2.gen();
        assert_eq!(value, Centimeter3PerSecond2::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter3PerSecond2::new(-5.0), Centimeter3PerSecond2::new(7.0)));
        assert_eq!(value, Centimeter3PerSecond2::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Centimeter3PerSecond3<f64>  = rng2.gen();
        assert_eq!(value, Centimeter3PerSecond3::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Centimeter3PerSecond3::new(-5.0), Centimeter3PerSecond3::new(7.0)));
        assert_eq!(value, Centimeter3PerSecond3::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Gal<f64>  = rng2.gen();
        assert_eq!(value, Gal::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Gal::new(-5.0), Gal::new(7.0)));
        assert_eq!(value, Gal::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Dyne<f64>  = rng2.gen();
        assert_eq!(value, Dyne::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Dyne::new(-5.0), Dyne::new(7.0)));
        assert_eq!(value, Dyne::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Erg<f64>  = rng2.gen();
        assert_eq!(value, Erg::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Erg::new(-5.0), Erg::new(7.0)));
        assert_eq!(value, Erg::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: ErgPerSecond<f64>  = rng2.gen();
        assert_eq!(value, ErgPerSecond::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(ErgPerSecond::new(-5.0), ErgPerSecond::new(7.0)));
        assert_eq!(value, ErgPerSecond::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Barye<f64>  = rng2.gen();
        assert_eq!(value, Barye::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Barye::new(-5.0), Barye::new(7.0)));
        assert_eq!(value, Barye::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Poise<f64>  = rng2.gen();
        assert_eq!(value, Poise::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Poise::new(-5.0), Poise::new(7.0)));
        assert_eq!(value, Poise::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Stokes<f64>  = rng2.gen();
        assert_eq!(value, Stokes::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Stokes::new(-5.0), Stokes::new(7.0)));
        assert_eq!(value, Stokes::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: Kayser<f64>  = rng2.gen();
        assert_eq!(value, Kayser::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(Kayser::new(-5.0), Kayser::new(7.0)));
        assert_eq!(value, Kayser::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: StatCoulomb<f64>  = rng2.gen();
        assert_eq!(value, StatCoulomb::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(StatCoulomb::new(-5.0), StatCoulomb::new(7.0)));
        assert_eq!(value, StatCoulomb::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: StatAmpere<f64>  = rng2.gen();
        assert_eq!(value, StatAmpere::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(StatAmpere::new(-5.0), StatAmpere::new(7.0)));
        assert_eq!(value, StatAmpere::new(raw_value));

        let raw_value: f64 = rng1.gen();
        let value: StatVolt<f64>  = rng2.gen();
        assert_eq!(value, StatVolt::new(raw_value));

        let raw_value = rng1.sample(Uniform::new(-5.0, 7.0));
        let value = rng2.sample(Uniform::new(StatVolt::new(-5.0), StatVolt::new(7.0)));
        assert_eq!(value, StatVolt::new(raw_value));

    }
    /// Test that clapme can generate a help message, and can produce a value.
    #[cfg(feature = "clapme")]
    #[test]
    fn test_cgs_clapme() {

        let value = 3.0 * SQRTCM;
        assert_eq!(value,
                   <SqrtCentimeter<f64> as ClapMe>::from_iter(&["test", "3.0"]).unwrap());

        let value = 3.0 * SQRTG;
        assert_eq!(value,
                   <SqrtGram<f64> as ClapMe>::from_iter(&["test", "3.0"]).unwrap());

        let value = 3.0 * S;
        assert_eq!(value,
                   <Second<f64> as ClapMe>::from_iter(&["test", "3.0"]).unwrap());

    }

    /// Test that clapme can generate a help message, and can produce a value.
    #[cfg(feature = "auto-args")]
    #[test]
    fn test_cgs_auto_args() {

        let value = 3.0 * SQRTCM;
        assert_eq!(value,
                   <SqrtCentimeter<f64> as auto_args::AutoArgs>::from_iter(&["test", "3.0"]).unwrap());

        let value = 3.0 * SQRTG;
        assert_eq!(value,
                   <SqrtGram<f64> as auto_args::AutoArgs>::from_iter(&["test", "3.0"]).unwrap());

        let value = 3.0 * S;
        assert_eq!(value,
                   <Second<f64> as auto_args::AutoArgs>::from_iter(&["test", "3.0"]).unwrap());

    }
}