ancomplex 0.0.5

Package provides easy to use, begginer frendly and python like complex numbers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use crate::{complex, Complex};
use num_traits::{AsPrimitive, FromPrimitive, Num, NumCast, ToPrimitive};

macro_rules! impl_toprim {
    ($ty:ty, $tofn:ident) => {
        fn $tofn(&self) -> Option<$ty> {
            if self.imag.is_zero() {
                self.real.$tofn()
            } else {
                None
            }
        }
    };
}
macro_rules! impl_fprim {
    ($ty:ty, $fromfn:ident) => {
        fn $fromfn(n: $ty) -> Option<Complex<T>> {
            Some(complex(T::$fromfn(n)?, T::zero()))
        }
    };
}

impl<T: ToPrimitive + Num> ToPrimitive for Complex<T> {
    impl_toprim!(u8, to_u8);
    impl_toprim!(u16, to_u16);
    impl_toprim!(u32, to_u32);
    impl_toprim!(u64, to_u64);
    impl_toprim!(u128, to_u128);
    impl_toprim!(usize, to_usize);

    impl_toprim!(i8, to_i8);
    impl_toprim!(i16, to_i16);
    impl_toprim!(i32, to_i32);
    impl_toprim!(i64, to_i64);
    impl_toprim!(i128, to_i128);
    impl_toprim!(isize, to_isize);

    impl_toprim!(f32, to_f32);
    impl_toprim!(f64, to_f64);
}

impl<T: FromPrimitive + Num> FromPrimitive for Complex<T> {
    impl_fprim!(u8, from_u8);
    impl_fprim!(u16, from_u16);
    impl_fprim!(u32, from_u32);
    impl_fprim!(u64, from_u64);
    impl_fprim!(u128, from_u128);
    impl_fprim!(usize, from_usize);

    impl_fprim!(i8, from_i8);
    impl_fprim!(i16, from_i16);
    impl_fprim!(i32, from_i32);
    impl_fprim!(i64, from_i64);
    impl_fprim!(i128, from_i128);
    impl_fprim!(isize, from_isize);

    impl_fprim!(f32, from_f32);
    impl_fprim!(f64, from_f64);
}

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

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