tmn/complex/

mod.rs

//!Complex Numbers


///Structure for storing complex numbers
///
/// Структура для хранения комплексных чисел
#[derive(Copy, Clone)]
pub struct CNum {
    r:f32,
    i:f32
}

impl CNum {
    ///The function for creating a complex number from the real and imaginary parts
    ///
    ///Функция для создания комплексного числа из действительной и мнимой части
    ///
    /// # Example
    ///
    ///```
    /// use tmn::complex::CNum;
    /// let a = CNum::make(4_f32, -2_f32);
    /// assert_eq!((4_f32, -2_f32), a.get());
    /// ```
    pub fn make(r:f32, i:f32)->Self{ Self{r,i } }
    /// The method that returns a tuple consisting of the real and imaginary parts of a complex number
    ///
    /// Метод, возвращающий кортеж состоящий из действительной и мнимой части комплексного числа
    ///
    /// # Example
    /// ```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let a = cnum!(43_f32, 21_f32);
    /// assert_eq!((43_f32, 21_f32), a.get());
    /// ```
    pub fn get(&self) -> (f32, f32){ (self.r, self.i) }
    /// The method that returns a complex conjugate number
    ///
    /// Метод, возвращающий комплексно сопряженное число
    ///
    /// # Example
    /// ```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let a = cnum!(1_f32, 1_f32);
    /// let c = a.conj();
    /// assert_eq!((1_f32, -1_f32), c.get());
    /// ```
    pub fn conj(&self) -> CNum{CNum{r:self.r, i:-self.i}}
    ///The method that returns the modulus of a complex number
    ///
    ///Метод, возвращающий модуль комплексного числа
    ///
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let a = cnum!(3_f32, 4_f32);
    /// assert_eq!(5_f32, a.modl());
    /// ```
    pub fn modl(&self) -> f32{
        let mut temp = self.clone();
        temp.mult(&self.conj());
        temp.r.powf(0.5)
    }
    ///A method that adds another complex number to a given one
    ///
    ///Метод, прибавляющий другое комплексное число к данному
    ///
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(6_f32, 2_f32);
    /// a.add(&cnum!(4_f32, 8_f32));
    /// assert_eq!((10_f32, 10_f32), a.get());
    /// ```
    pub fn add(&mut self, v: &CNum){
        self.r += v.r;
        self.i += v.i;
    }
    /// The method that multiplies another complex number to a given one
    ///
    /// Метод, умножающий другое комплексное число к данному
    /// # Example
    /// ```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(3_f32, 2_f32);
    /// a.mult(&cnum!(5_f32, 3_f32));
    /// assert_eq!((9_f32, 19_f32), a.get());
    /// ```
    pub fn mult(&mut self, v:&CNum){
        let (r, i) = self.get();
        self.r = r * v.r - i * v.i;
        self.i = r * v.i + v.r * i;
    }
    ///The method that divides another complex number to a given one
    ///
    /// Метод, делящий данное комплексное число на другое
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(3_f32, 2_f32);
    /// a.div(&cnum!(5_f32, 3_f32));
    /// assert_eq!((21_f32/34_f32, 1_f32/34_f32), a.get());
    /// ```
    pub fn div(&mut self, v:&CNum){
        let mut vtemp = v.clone();
        vtemp.mult(&v.conj());
        let divisor = vtemp.r;
        let mut numerator = self.clone();
        numerator.mult(&v.conj());
        numerator.mult(&CNum::make(1_f32/divisor, 0.0));
        self.r = numerator.r;
        self.i = numerator.i;
    }
    /// The method for raising a complex number to a power. Degrees less than one (roots) are counted with k = 0
    ///
    /// Метод для возведения комплексного числа в степень. Степени меньше единицы (корни) считаются с k = 0
    ///
    /// # Example
    /// ```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(3_f32, 2_f32);
    /// a.pow(2_f32);
    /// let (r, i) = a.get();
    /// assert!((r-5_f32).abs() < 0.000001);
    /// assert!((i-12_f32).abs() < 0.000001);
    /// ```
    pub fn pow(&mut self, v:f32){
        let (r, i) = (self.r, self.i);
        let l = self.modl();
        self.r = l.powf(v)*(v * i.atan2(r)).cos();
        self.i = l.powf(v)*(v * i.atan2(r)).sin();
    }
    ///The method that replaces r value
    ///
    ///Метод заменяющий r значение
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(1_f32, 1_f32);
    /// a.set_r(0.0);
    /// assert_eq!((0_f32, 1_f32), a.get());
    /// ```
    pub fn set_r(&mut self, v:f32){
        self.r = v;
    }
    ///The method that replaces i value
    ///
    ///Метод заменяющий i значение
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(1_f32, 1_f32);
    /// a.set_i(0.0);
    /// assert_eq!((1_f32, 0_f32), a.get());
    /// ```
    pub fn set_i(&mut self, v:f32){
        self.i = v;
    }

    ///The method that normalizes complex number
    ///
    ///Метод нормализирующий комлпексное число
    /// # Example
    ///```
    /// use tmn::cnum;
    /// use tmn::complex::CNum;
    /// let mut a = cnum!(1_f32, 1_f32);
    /// a.unit();
    /// let (r, i) = a.get();
    /// //Ожидаемый ответ (0.707~, 0.707~)
    /// assert!((r-0.707).abs() < 0.001);
    /// assert!((i-0.707).abs() < 0.001);
    /// ```
    pub fn unit(&mut self){
        let l = self.modl();
        self.r /= l;
        self.i /= l;
    }
}

///The macros that creates complex number
///
///Макрос создающий комплексное число
/// # Example
///```
/// use tmn::cnum;
/// use tmn::complex::CNum;
/// let mut a = cnum!(1_f32, 1_f32);
/// assert_eq!((1_f32, 1_f32), a.get());
/// ```
#[macro_export]
macro_rules! cnum {
    ($r:expr) => {
        CNum::make(($r) as f32, 0f32)
    };
    ($r:expr, $i:expr) => {
        CNum::make(($r) as f32, ($i) as f32)
    };
}

impl PartialEq for CNum{
    fn eq(&self, other: &Self) -> bool {
        self.get()==other.get()
    }
}