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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

//!Provides easy to use, begginer frendly and python like complex numbers
//!## Examples
//!Create complex number
//! ```rust
//! use ancomplex::*;
//!        
//! fn main() {
//!     let c = complex(1, 2);
//!     //               \  \
//!     //                \  \
//!     //                 \  Imaginary Part of complex number
//!     //                  \
//!     //                   \
//!     //                    Real Part of complex number
//! }   
//! ```
//!Math operations
//! ```rust
//! use ancomplex::*;
//!        
//! fn main() {
//!     let c = complex(1, 2);
//!     let k = complex(3, 4);
//!
//!     println!("Sum of two complex numbers: {}", c+k);
//!     println!("Product of two complex numbers: {}", c*k);
//!     println!("Sub of two complex numbers: {}", c-k);
//!     println!("Div of two complex numbers: {}", c/k);
//! }
//! ```
//!More complex functions
//! ```rust
//! use ancomplex::*;
//!
//! fn main() {
//!     let c = complex(4, 5);
//!     let k = complex(6, 7);
//!
//!     println!("Conjugate of complex number: {}", c.conj());
//! }
//! ```
//!Fancy printing
//! ```rust
//! use ancomplex::*;
//!
//! fn main() {
//!     let c = complex(4, 2);
//!
//!     println!("{}", c); // Output: 4+2i
//! }
//! ```
//!
#[cfg(test)]
mod tests;

extern crate num_traits;

pub(crate) mod cast;
pub(crate) mod complex_assing_ops;
pub(crate) mod complex_ops;
pub(crate) mod complexc;
pub(crate) mod complexfmt;
pub(crate) mod num_traits_impl;
pub use complexc::Complex;

/// Function to init `Complex` struct (*Recomed way to init complex numbers*)
pub fn complex<T>(real: T, imag: T) -> Complex<T> {
    Complex { real, imag }
}
#[allow(non_camel_case_types)]
/// type alias for Float32 Complex number
pub type c32 = Complex<f32>;

#[allow(non_camel_case_types)]
/// type alias for Float64 Complex number
pub type c64 = Complex<f64>;

/// Function for init float32 complex number
pub fn c32<T: Into<f32>>(real: T, imag: T) -> Complex<f32> {
    Complex {
        real: real.into(),
        imag: imag.into(),
    }
}
/// Function for init float64 complex number
pub fn c64<T: Into<f64>>(real: T, imag: T) -> Complex<f64> {
    Complex {
        real: real.into(),
        imag: imag.into(),
    }
}