/rust/registry/src/index.crates.io-1949cf8c6b5b557f/num-complex-0.4.6/src/cast.rs

Source
use super::Complex;
use num_traits::{AsPrimitive, FromPrimitive, Num, NumCast, ToPrimitive};

macro_rules! impl_to_primitive {
    ($ty:ty, $to:ident) => {
        #[inline]
        fn $to(&self) -> Option<$ty> {
            if self.im.is_zero() {
                self.re.$to()
            } else {
                None
            }
        }
    };
} // impl_to_primitive

// Returns None if Complex part is non-zero
impl<T: ToPrimitive + Num> ToPrimitive for Complex<T> {
    impl_to_primitive!(usize, to_usize);
    impl_to_primitive!(isize, to_isize);
    impl_to_primitive!(u8, to_u8);
    impl_to_primitive!(u16, to_u16);
    impl_to_primitive!(u32, to_u32);
    impl_to_primitive!(u64, to_u64);
    impl_to_primitive!(i8, to_i8);
    impl_to_primitive!(i16, to_i16);
    impl_to_primitive!(i32, to_i32);
    impl_to_primitive!(i64, to_i64);
    impl_to_primitive!(u128, to_u128);
    impl_to_primitive!(i128, to_i128);
    impl_to_primitive!(f32, to_f32);
    impl_to_primitive!(f64, to_f64);
}

macro_rules! impl_from_primitive {
    ($ty:ty, $from_xx:ident) => {
        #[inline]
        fn $from_xx(n: $ty) -> Option<Self> {
            Some(Complex {
                re: T::$from_xx(n)?,
                im: T::zero(),
            })
        }
    };
} // impl_from_primitive

impl<T: FromPrimitive + Num> FromPrimitive for Complex<T> {
    impl_from_primitive!(usize, from_usize);
    impl_from_primitive!(isize, from_isize);
    impl_from_primitive!(u8, from_u8);
    impl_from_primitive!(u16, from_u16);
    impl_from_primitive!(u32, from_u32);
    impl_from_primitive!(u64, from_u64);
    impl_from_primitive!(i8, from_i8);
    impl_from_primitive!(i16, from_i16);
    impl_from_primitive!(i32, from_i32);
    impl_from_primitive!(i64, from_i64);
    impl_from_primitive!(u128, from_u128);
    impl_from_primitive!(i128, from_i128);
    impl_from_primitive!(f32, from_f32);
    impl_from_primitive!(f64, from_f64);
}

impl<T: NumCast + Num> NumCast for Complex<T> {
    fn from<U: ToPrimitive>(n: U) -> Option<Self> {
        Some(Complex {
            re: T::from(n)?,
            im: T::zero(),
        })
    }
}

impl<T, U> AsPrimitive<U> for Complex<T>
where
    T: AsPrimitive<U>,
    U: 'static + Copy,
{
    fn as_(self) -> U {
        self.re.as_()
    }
}

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

    #[test]
    fn test_to_primitive() {
        let a: Complex<u32> = Complex { re: 3, im: 0 };
        assert_eq!(a.to_i32(), Some(3_i32));
        let b: Complex<u32> = Complex { re: 3, im: 1 };
        assert_eq!(b.to_i32(), None);
        let x: Complex<f32> = Complex { re: 1.0, im: 0.1 };
        assert_eq!(x.to_f32(), None);
        let y: Complex<f32> = Complex { re: 1.0, im: 0.0 };
        assert_eq!(y.to_f32(), Some(1.0));
        let z: Complex<f32> = Complex { re: 1.0, im: 0.0 };
        assert_eq!(z.to_i32(), Some(1));
    }

    #[test]
    fn test_from_primitive() {
        let a: Complex<f32> = FromPrimitive::from_i32(2).unwrap();
        assert_eq!(a, Complex { re: 2.0, im: 0.0 });
    }

    #[test]
    fn test_num_cast() {
        let a: Complex<f32> = NumCast::from(2_i32).unwrap();
        assert_eq!(a, Complex { re: 2.0, im: 0.0 });
    }

    #[test]
    fn test_as_primitive() {
        let a: Complex<f32> = Complex { re: 2.0, im: 0.2 };
        let a_: i32 = a.as_();
        assert_eq!(a_, 2_i32);
    }
}

Coverage Report

Created: 2025-11-28 06:44

Line	Count	Source
1		use super::Complex;
2		use num_traits::{AsPrimitive, FromPrimitive, Num, NumCast, ToPrimitive};
3
4		macro_rules! impl_to_primitive {
5		($ty:ty, $to:ident) => {
6		#[inline]
7	0	fn $to(&self) -> Option<$ty> {
8	0	if self.im.is_zero() {
9	0	self.re.$to()
10		} else {
11	0	None
12		}
13	0	} Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_i8 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_u8 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_f32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_f64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_i16 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_i32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_i64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_u16 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_u32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_u64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_i128 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_u128 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_isize Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::ToPrimitive>::to_usize
14		};
15		} // impl_to_primitive
16
17		// Returns None if Complex part is non-zero
18		impl<T: ToPrimitive + Num> ToPrimitive for Complex<T> {
19		impl_to_primitive!(usize, to_usize);
20		impl_to_primitive!(isize, to_isize);
21		impl_to_primitive!(u8, to_u8);
22		impl_to_primitive!(u16, to_u16);
23		impl_to_primitive!(u32, to_u32);
24		impl_to_primitive!(u64, to_u64);
25		impl_to_primitive!(i8, to_i8);
26		impl_to_primitive!(i16, to_i16);
27		impl_to_primitive!(i32, to_i32);
28		impl_to_primitive!(i64, to_i64);
29		impl_to_primitive!(u128, to_u128);
30		impl_to_primitive!(i128, to_i128);
31		impl_to_primitive!(f32, to_f32);
32		impl_to_primitive!(f64, to_f64);
33		}
34
35		macro_rules! impl_from_primitive {
36		($ty:ty, $from_xx:ident) => {
37		#[inline]
38	0	fn $from_xx(n: $ty) -> Option<Self> {
39		Some(Complex {
40	0	re: T::$from_xx(n)?,
41	0	im: T::zero(),
42		})
43	0	} Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_isize Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_usize Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_i8 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_u8 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_f32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_f64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_i16 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_i32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_i64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_u16 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_u32 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_u64 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_i128 Unexecuted instantiation: <num_complex::Complex<_> as num_traits::cast::FromPrimitive>::from_u128
44		};
45		} // impl_from_primitive
46
47		impl<T: FromPrimitive + Num> FromPrimitive for Complex<T> {
48		impl_from_primitive!(usize, from_usize);
49		impl_from_primitive!(isize, from_isize);
50		impl_from_primitive!(u8, from_u8);
51		impl_from_primitive!(u16, from_u16);
52		impl_from_primitive!(u32, from_u32);
53		impl_from_primitive!(u64, from_u64);
54		impl_from_primitive!(i8, from_i8);
55		impl_from_primitive!(i16, from_i16);
56		impl_from_primitive!(i32, from_i32);
57		impl_from_primitive!(i64, from_i64);
58		impl_from_primitive!(u128, from_u128);
59		impl_from_primitive!(i128, from_i128);
60		impl_from_primitive!(f32, from_f32);
61		impl_from_primitive!(f64, from_f64);
62		}
63
64		impl<T: NumCast + Num> NumCast for Complex<T> {
65	0	fn from<U: ToPrimitive>(n: U) -> Option<Self> {
66		Some(Complex {
67	0	re: T::from(n)?,
68	0	im: T::zero(),
69		})
70	0	}
71		}
72
73		impl<T, U> AsPrimitive<U> for Complex<T>
74		where
75		T: AsPrimitive<U>,
76		U: 'static + Copy,
77		{
78	0	fn as_(self) -> U {
79	0	self.re.as_()
80	0	}
81		}
82
83		#[cfg(test)]
84		mod test {
85		use super::*;
86
87		#[test]
88		fn test_to_primitive() {
89		let a: Complex<u32> = Complex { re: 3, im: 0 };
90		assert_eq!(a.to_i32(), Some(3_i32));
91		let b: Complex<u32> = Complex { re: 3, im: 1 };
92		assert_eq!(b.to_i32(), None);
93		let x: Complex<f32> = Complex { re: 1.0, im: 0.1 };
94		assert_eq!(x.to_f32(), None);
95		let y: Complex<f32> = Complex { re: 1.0, im: 0.0 };
96		assert_eq!(y.to_f32(), Some(1.0));
97		let z: Complex<f32> = Complex { re: 1.0, im: 0.0 };
98		assert_eq!(z.to_i32(), Some(1));
99		}
100
101		#[test]
102		fn test_from_primitive() {
103		let a: Complex<f32> = FromPrimitive::from_i32(2).unwrap();
104		assert_eq!(a, Complex { re: 2.0, im: 0.0 });
105		}
106
107		#[test]
108		fn test_num_cast() {
109		let a: Complex<f32> = NumCast::from(2_i32).unwrap();
110		assert_eq!(a, Complex { re: 2.0, im: 0.0 });
111		}
112
113		#[test]
114		fn test_as_primitive() {
115		let a: Complex<f32> = Complex { re: 2.0, im: 0.2 };
116		let a_: i32 = a.as_();
117		assert_eq!(a_, 2_i32);
118		}
119		}