復數(shù)

基本概念

復數(shù)定義

由實數(shù)部分和虛數(shù)部分所組成的數(shù)，形如a＋bi 。

其中a、b為實數(shù)，i 為“虛數(shù)單位”，i2 = -1，即虛數(shù)單位的平方等于-1。

a、b分別叫做復數(shù)a＋bi的實部和虛部。

當b=0時，a＋bi＝a 為實數(shù)；
當b≠0時，a＋bi 又稱虛數(shù)；
當b≠0、a=0時，bi 稱為純虛數(shù)。

實數(shù)和虛數(shù)都是復數(shù)的子集。如同實數(shù)可以在數(shù)軸上表示一樣復數(shù)也可以在平面上表示，復數(shù)x+yi以坐標點(x，y)來表示。表示復數(shù)的平面稱為“復平面”。

復數(shù)相等

兩個復數(shù)不能比較大小，但當個兩個復數(shù)的實部和虛部分別相等時，即表示兩個復數(shù)相等。

共軛復數(shù)

如果兩個復數(shù)的實部相等，虛部互為相反數(shù)，那么這兩個復數(shù)互為共軛復數(shù)。

復數(shù)的模

復數(shù)的實部與虛部的平方和的正的平方根的值稱為該復數(shù)的模，數(shù)學上用與絕對值“|z|”相同的符號來表示。雖然從定義上是不相同的，但兩者的物理意思都表示“到原點的距離”。

復數(shù)的四則運算

加法（減法）法則

復數(shù)的加法法則：設z1=a+bi,z2 =c+di是任意兩個復數(shù)。兩者和的實部是原來兩個復數(shù)實部的和，它的虛部是原來兩個虛部的和。兩個復數(shù)的和依然是復數(shù)。

即(a+bi)±(c+di)=(a±c)+(b±d)

乘法法則

復數(shù)的乘法法則：把兩個復數(shù)相乘，類似兩個多項式相乘，結果中i2=-1，把實部與虛部分別合并。兩個復數(shù)的積仍然是一個復數(shù)。

即(a+bi)(c+di)=(ac-bd)+(bc+ad)i

除法法則

復數(shù)除法法則：滿足(c+di)(x+yi)=(a+bi)的復數(shù)x+yi(x,y∈R)叫復數(shù)a+bi除以復數(shù)c+di的商。

運算方法：可以把除法換算成乘法做，將分子分母同時乘上分母的共軛復數(shù)，再用乘法運算。

即(a+bi)/(c+di)=(a+bi)(c-di)/(c*c+d*d)=[(ac+bd)+(bc-ad)i]/(c*c+d*d)

復數(shù)的Rust代碼實現(xiàn)

結構定義

Rust語言中，沒有像python一樣內(nèi)置complex復數(shù)數(shù)據(jù)類型，我們可以用兩個浮點數(shù)分別表示復數(shù)的實部和虛部，自定義一個結構數(shù)據(jù)類型，表示如下：

struct Complex {
? ? real: f64,
? ? imag: f64,
}

示例代碼：

#[derive(Debug)]
struct Complex {
    real: f64,
    imag: f64,
}

impl Complex {  
    fn new(real: f64, imag: f64) -> Self {
        Complex { real, imag }  
    }
}

fn main() {  
    let z = Complex::new(3.0, 4.0);
    println!("{:?}", z);
    println!("{} + {}i", z.real, z.imag);
}

注意：#[derive(Debug)] 自動定義了復數(shù)結構的輸出格式，如以上代碼輸出如下：

Complex { real: 3.0, imag: 4.0 }
3 + 4i

重載四則運算

復數(shù)數(shù)據(jù)結構不能直接用加減乘除來做復數(shù)運算，需要導入標準庫ops的運算符：

use std::ops::{Add, Sub, Mul, Div, Neg};

Add, Sub, Mul, Div, Neg 分別表示加減乘除以及相反數(shù)，類似C++或者python語言中“重載運算符”的概念。

根據(jù)復數(shù)的運算法則，寫出對應代碼：

fn add(self, other: Complex) -> Complex {
? ? Complex {
? ? ? ? real: self.real + other.real,
? ? ? ? imag: self.imag + other.imag,
? ? } ?
} ?

fn sub(self, other: Complex) -> Complex {
? ? Complex { ?
? ? ? ? real: self.real - other.real,
? ? ? ? imag: self.imag - other.imag,
? ? } ?
}?

fn mul(self, other: Complex) -> Complex { ?
? ? let real = self.real * other.real - self.imag * other.imag;
? ? let imag = self.real * other.imag + self.imag * other.real;
? ? Complex { real, imag } ?
} ?

fn div(self, other: Complex) -> Complex {
? ? let real = (self.real * other.real + self.imag * other.imag) / (other.real * other.real + other.imag * other.imag);
? ? let imag = (self.imag * other.real - self.real * other.imag) / (other.real * other.real + other.imag * other.imag);
? ? Complex { real, imag }
}

fn neg(self) -> Complex {
? ? Complex {
? ? ? ? real: -self.real,
? ? ? ? imag: -self.imag,
? ? }
}

Rust 重載運算的格式，請見如下示例代碼：

use std::ops::{Add, Sub, Mul, Div, Neg};

#[derive(Clone, Debug, PartialEq)]
struct Complex {
    real: f64,
    imag: f64,
}

impl Complex {  
    fn new(real: f64, imag: f64) -> Self {
        Complex { real, imag }  
    }
  
    fn conj(&self) -> Self {
        Complex { real: self.real, imag: -self.imag }
    }

    fn abs(&self) -> f64 {
        (self.real * self.real + self.imag * self.imag).sqrt()
    }
}

fn abs(z: Complex) -> f64 {
    (z.real * z.real + z.imag * z.imag).sqrt()
}

impl Add<Complex> for Complex {
    type Output = Complex;

    fn add(self, other: Complex) -> Complex {
        Complex {
            real: self.real + other.real,
            imag: self.imag + other.imag,
        }  
    }  
}  
  
impl Sub<Complex> for Complex {
    type Output = Complex;
  
    fn sub(self, other: Complex) -> Complex {
        Complex {  
            real: self.real - other.real,
            imag: self.imag - other.imag,
        }  
    } 
}  
  
impl Mul<Complex> for Complex {
    type Output = Complex;  
  
    fn mul(self, other: Complex) -> Complex {  
        let real = self.real * other.real - self.imag * other.imag;
        let imag = self.real * other.imag + self.imag * other.real;
        Complex { real, imag }  
    }  
}

impl Div<Complex> for Complex {
    type Output = Complex;
  
    fn div(self, other: Complex) -> Complex {
        let real = (self.real * other.real + self.imag * other.imag) / (other.real * other.real + other.imag * other.imag);
        let imag = (self.imag * other.real - self.real * other.imag) / (other.real * other.real + other.imag * other.imag);
        Complex { real, imag }
    }
}  
  
impl Neg for Complex {
    type Output = Complex;
  
    fn neg(self) -> Complex {
        Complex {
            real: -self.real,
            imag: -self.imag,
        }
    }
}

fn main() {  
    let z1 = Complex::new(2.0, 3.0);
    let z2 = Complex::new(3.0, 4.0);
    let z3 = Complex::new(3.0, -4.0);

    // 復數(shù)的四則運算
    let complex_add = z1.clone() + z2.clone();
    println!("{:?} + {:?} = {:?}", z1, z2, complex_add);

    let complex_sub = z1.clone() - z2.clone();
    println!("{:?} - {:?} = {:?}", z1, z2, complex_sub);

    let complex_mul = z1.clone() * z2.clone();
    println!("{:?} * {:?} = {:?}", z1, z2, complex_mul);

    let complex_div = z2.clone() / z3.clone();
    println!("{:?} / {:?} = {:?}", z1, z2, complex_div);

    // 對比兩個復數(shù)是否相等
    println!("{:?}", z1 == z2);
    // 共軛復數(shù)
    println!("{:?}", z2 == z3.conj());
    // 復數(shù)的相反數(shù)
    println!("{:?}", z2 == -z3.clone() + Complex::new(6.0,0.0));

    // 復數(shù)的模
    println!("{}", z1.abs());
    println!("{}", z2.abs());
    println!("{}", abs(z3));
}

輸出：

Complex { real: 2.0, imag: 3.0 } + Complex { real: 3.0, imag: 4.0 } = Complex { real: 5.0, imag: 7.0 }
Complex { real: 2.0, imag: 3.0 } - Complex { real: 3.0, imag: 4.0 } = Complex { real: -1.0, imag: -1.0 }
Complex { real: 2.0, imag: 3.0 } * Complex { real: 3.0, imag: 4.0 } = Complex { real: -6.0, imag: 17.0 }
Complex { real: 2.0, imag: 3.0 } / Complex { real: 3.0, imag: 4.0 } = Complex { real: -0.28, imag: 0.96 }
false
true
true
3.605551275463989
5
5

示例代碼中，同時還定義了復數(shù)的模 abs()，共軛復數(shù) conj()。

兩個復數(shù)的相等比較 z1 == z2，需要?#[derive(PartialEq)] 支持。

自定義 trait Display

復數(shù)結構的原始 Debug trait 表達的輸出格式比較繁復，如：

Complex { real: 2.0, imag: 3.0 } + Complex { real: 3.0, imag: 4.0 } = Complex { real: 5.0, imag: 7.0 }

想要輸出和數(shù)學中相同的表達(如 a + bi)，需要自定義一個 Display trait，代碼如下：

impl std::fmt::Display for Complex {
? ? fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
? ? ? ? if self.imag == 0.0 {
? ? ? ? ? ? formatter.write_str(&format!("{}", self.real))
? ? ? ? } else {
? ? ? ? ? ? let (abs, sign) = if self.imag > 0.0 { ?
? ? ? ? ? ? ? ? (self.imag, "+" )
? ? ? ? ? ? } else {
? ? ? ? ? ? ? ? (-self.imag, "-" )
? ? ? ? ? ? };
? ? ? ? ? ? if abs == 1.0 {
? ? ? ? ? ? ? ? formatter.write_str(&format!("({} {} i)", self.real, sign))
? ? ? ? ? ? } else {
? ? ? ? ? ? ? ? formatter.write_str(&format!("({} {} {}i)", self.real, sign, abs))
? ? ? ? ? ? }
? ? ? ? }
? ? }
}

輸出格式分三種情況：虛部為0，正數(shù)和負數(shù)。另外當虛部絕對值為1時省略1僅輸出i虛數(shù)單位。

完整代碼如下：

use std::ops::{Add, Sub, Mul, Div, Neg};

#[derive(Clone, PartialEq)]
struct Complex {
    real: f64,
    imag: f64,
}

impl std::fmt::Display for Complex {
    fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
        if self.imag == 0.0 {
            formatter.write_str(&format!("{}", self.real))
        } else {
            let (abs, sign) = if self.imag > 0.0 {  
                (self.imag, "+" )
            } else {
                (-self.imag, "-" )
            };
            if abs == 1.0 {
                formatter.write_str(&format!("({} {} i)", self.real, sign))
            } else {
                formatter.write_str(&format!("({} {} {}i)", self.real, sign, abs))
            }
        }
    }
}

impl Complex {  
    fn new(real: f64, imag: f64) -> Self {
        Complex { real, imag }  
    }
  
    fn conj(&self) -> Self {
        Complex { real: self.real, imag: -self.imag }
    }

    fn abs(&self) -> f64 {
        (self.real * self.real + self.imag * self.imag).sqrt()
    }
}

fn abs(z: Complex) -> f64 {
    (z.real * z.real + z.imag * z.imag).sqrt()
}

impl Add<Complex> for Complex {
    type Output = Complex;

    fn add(self, other: Complex) -> Complex {
        Complex {
            real: self.real + other.real,
            imag: self.imag + other.imag,
        }  
    }  
}  
  
impl Sub<Complex> for Complex {
    type Output = Complex;
  
    fn sub(self, other: Complex) -> Complex {
        Complex {  
            real: self.real - other.real,
            imag: self.imag - other.imag,
        }  
    } 
}  
  
impl Mul<Complex> for Complex {
    type Output = Complex;  
  
    fn mul(self, other: Complex) -> Complex {  
        let real = self.real * other.real - self.imag * other.imag;
        let imag = self.real * other.imag + self.imag * other.real;
        Complex { real, imag }  
    }  
}

impl Div<Complex> for Complex {
    type Output = Complex;
  
    fn div(self, other: Complex) -> Complex {
        let real = (self.real * other.real + self.imag * other.imag) / (other.real * other.real + other.imag * other.imag);
        let imag = (self.imag * other.real - self.real * other.imag) / (other.real * other.real + other.imag * other.imag);
        Complex { real, imag }
    }
}  
  
impl Neg for Complex {
    type Output = Complex;
  
    fn neg(self) -> Complex {
        Complex {
            real: -self.real,
            imag: -self.imag,
        }
    }
}

fn main() {
    let z1 = Complex::new(2.0, 3.0);
    let z2 = Complex::new(3.0, 4.0);
    let z3 = Complex::new(3.0, -4.0);

    // 復數(shù)的四則運算
    let complex_add = z1.clone() + z2.clone();
    println!("{} + {} = {}", z1, z2, complex_add);

    let z = Complex::new(1.5, 0.5);
    println!("{} + {} = {}", z, z, z.clone() + z.clone());

    let complex_sub = z1.clone() - z2.clone();
    println!("{} - {} = {}", z1, z2, complex_sub);

    let complex_sub = z1.clone() - z1.clone();
    println!("{} - {} = {}", z1, z1, complex_sub);

    let complex_mul = z1.clone() * z2.clone();
    println!("{} * {} = {}", z1, z2, complex_mul);

    let complex_mul = z2.clone() * z3.clone();
    println!("{} * {} = {}", z2, z3, complex_mul);

    let complex_div = z2.clone() / z3.clone();
    println!("{} / {} = {}", z1, z2, complex_div);

    let complex_div = Complex::new(1.0,0.0) / z2.clone();
    println!("1 / {} = {}", z2, complex_div);

    // 對比兩個復數(shù)是否相等
    println!("{:?}", z1 == z2);
    // 共軛復數(shù)
    println!("{:?}", z2 == z3.conj());
    // 復數(shù)的相反數(shù)
    println!("{:?}", z2 == -z3.clone() + Complex::new(6.0,0.0));

    // 復數(shù)的模
    println!("{}", z1.abs());
    println!("{}", z2.abs());
    println!("{}", abs(z3));
}

輸出：

(2 + 3i) + (3 + 4i) = (5 + 7i)
(1.5 + 0.5i) + (1.5 + 0.5i) = (3 + i)
(2 + 3i) - (3 + 4i) = (-1 - i)
(2 + 3i) - (2 + 3i) = 0
(2 + 3i) * (3 + 4i) = (-6 + 17i)
(3 + 4i) * (3 - 4i) = 25
(2 + 3i) / (3 + 4i) = (-0.28 + 0.96i)
1 / (3 + 4i) = (0.12 - 0.16i)
false
true
true
3.605551275463989
5
5

小結

如此，復數(shù)的四則運算基本都實現(xiàn)了，當然復數(shù)還有三角表示式和指數(shù)表示式，根據(jù)它們的數(shù)學定義寫出相當代碼應該不是很難。有了復數(shù)三角式，就能方便地定義出復數(shù)的開方運算，有空可以寫寫這方面的代碼。

本文完文章來源地址http://www.zghlxwxcb.cn/news/detail-648762.html

到了這里，關于Rust 重載運算符｜復數(shù)結構的“加減乘除”四則運算的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關文章，希望大家以后多多支持TOY模板網(wǎng)！