pub mod uncval {
    use num::traits::Float;

    pub trait UncertainValue<T: Float> {
        fn as_ab(self) -> AbUncVal<T>;
        fn as_rel(self) -> RelUncVal<T>;
    }

    pub struct UncVal;

    #[derive(Copy, Clone)]
    pub struct AbUncVal<T>
    where
        T: Float,
    {
        pub val: T,
        pub unc: T,
    }

    #[derive(Copy, Clone)]
    pub struct RelUncVal<T>
    where
        T: Float,
    {
        pub val: T,
        pub unc: T,
    }

    impl UncVal {
        pub fn ab<T: Float>(val: T, unc: T) -> AbUncVal<T> {
            AbUncVal { val, unc }
        }

        pub fn rel<T: Float>(val: T, unc: T) -> RelUncVal<T> {
            RelUncVal { val, unc }
        }
    }

    impl<T: Float> UncertainValue<T> for AbUncVal<T> {
        fn as_ab(self) -> AbUncVal<T> {
            self
        }

        fn as_rel(self) -> RelUncVal<T> {
            RelUncVal {
                val: self.val,
                unc: self.unc / self.val,
            }
        }
    }

    impl<T: Float> UncertainValue<T> for RelUncVal<T> {
        fn as_ab(self) -> AbUncVal<T> {
            AbUncVal {
                val: self.val,
                unc: self.val * self.unc,
            }
        }

        fn as_rel(self) -> RelUncVal<T> {
            self
        }
    }

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

        #[test]
        fn test_ab_constructor() {
            let u = UncVal::ab(10.0f64, 1.0);
            assert_eq!(u.val, 10.0);
            assert_eq!(u.unc, 1.0);
        }

        #[test]
        fn test_rel_constructor() {
            let u = UncVal::rel(10.0f64, 0.1);
            assert_eq!(u.val, 10.0);
            assert_eq!(u.unc, 0.1);
        }
    }
}

pub mod uncvec {
    use num::traits::Float;

    pub struct UncVec;

    pub struct AbUncVec<T>
    where
        T: Float,
    {
        pub vals: Vec<T>,
        pub unc: T,
    }

    pub struct RelUncVec<T>
    where
        T: Float,
    {
        pub vals: Vec<T>,
        pub unc: T,
    }

    impl UncVec {
        pub fn ab<T: Float>(vals: Vec<T>, unc: T) -> AbUncVec<T> {
            AbUncVec { vals, unc }
        }

        pub fn rel<T: Float>(vals: Vec<T>, unc: T) -> RelUncVec<T> {
            RelUncVec { vals, unc }
        }
    }

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

        #[test]
        fn test_ab_constructor() {
            let v = vec![1.0f64, 2.0, 3.0];
            let uv = UncVec::ab(v.clone(), 0.1);
            assert_eq!(uv.vals, v);
            assert_eq!(uv.unc, 0.1);
        }

        #[test]
        fn test_rel_constructor() {
            let v = vec![1.0f64, 2.0, 3.0];
            let uv = UncVec::rel(v.clone(), 0.1);
            assert_eq!(uv.vals, v);
            assert_eq!(uv.unc, 0.1);
        }
    }
}