Rust重載運算符之復(fù)數(shù)四則運算的實現(xiàn)
基本概念
復(fù)數(shù)定義
由實數(shù)部分和虛數(shù)部分所組成的數(shù)，形如a＋bi 。
其中a、b為實數(shù)，i 為“虛數(shù)單位”，i² = -1，即虛數(shù)單位的平方等于-1。
a、b分別叫做復(fù)數(shù)a＋bi的實部和虛部。
- 當(dāng)b=0時，a＋bi＝a 為實數(shù)；
- 當(dāng)b≠0時，a＋bi 又稱虛數(shù)；
- 當(dāng)b≠0、a=0時，bi 稱為純虛數(shù)。
實數(shù)和虛數(shù)都是復(fù)數(shù)的子集。如同實數(shù)可以在數(shù)軸上表示一樣復(fù)數(shù)也可以在平面上表示，復(fù)數(shù)x+yi以坐標(biāo)點(x，y)來表示。表示復(fù)數(shù)的平面稱為“復(fù)平面”。
復(fù)數(shù)相等
兩個復(fù)數(shù)不能比較大小，但當(dāng)個兩個復(fù)數(shù)的實部和虛部分別相等時，即表示兩個復(fù)數(shù)相等。
共軛復(fù)數(shù)
如果兩個復(fù)數(shù)的實部相等，虛部互為相反數(shù)，那么這兩個復(fù)數(shù)互為共軛復(fù)數(shù)。
復(fù)數(shù)的模
復(fù)數(shù)的實部與虛部的平方和的正的平方根的值稱為該復(fù)數(shù)的模，數(shù)學(xué)上用與絕對值“|z|”相同的符號來表示。雖然從定義上是不相同的，但兩者的物理意思都表示“到原點的距離”。
復(fù)數(shù)的四則運算
加法（減法）法則
復(fù)數(shù)的加法法則：設(shè)z1=a+bi,z2 =c+di是任意兩個復(fù)數(shù)。兩者和的實部是原來兩個復(fù)數(shù)實部的和，它的虛部是原來兩個虛部的和。兩個復(fù)數(shù)的和依然是復(fù)數(shù)。
即(a+bi)±(c+di)=(a±c)+(b±d)
乘法法則
復(fù)數(shù)的乘法法則：把兩個復(fù)數(shù)相乘，類似兩個多項式相乘，結(jié)果中i²=-1，把實部與虛部分別合并。兩個復(fù)數(shù)的積仍然是一個復(fù)數(shù)。
即(a+bi)(c+di)=(ac-bd)+(bc+ad)i
除法法則
數(shù)除法法則：滿足(c+di)(x+yi)=(a+bi)的復(fù)數(shù)x+yi(x,y∈R)叫復(fù)數(shù)a+bi除以復(fù)數(shù)c+di的商。
運算方法：可以把除法換算成乘法做，將分子分母同時乘上分母的共軛復(fù)數(shù)，再用乘法運算。
即(a+bi)/(c+di)=(a+bi)(c-di)/(c*c+d*d)=[(ac+bd)+(bc-ad)i]/(c*c+d*d)
復(fù)數(shù)的Rust代碼實現(xiàn)
結(jié)構(gòu)定義
Rust語言中，沒有像python一樣內(nèi)置complex復(fù)數(shù)數(shù)據(jù)類型，我們可以用兩個浮點數(shù)分別表示復(fù)數(shù)的實部和虛部，自定義一個結(jié)構(gòu)數(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)] 自動定義了復(fù)數(shù)結(jié)構(gòu)的輸出格式，如以上代碼輸出如下：
Complex { real: 3.0, imag: 4.0 }
3 + 4i
重載四則運算
復(fù)數(shù)數(shù)據(jù)結(jié)構(gòu)不能直接用加減乘除來做復(fù)數(shù)運算，需要導(dǎo)入標(biāo)準(zhǔn)庫ops的運算符：
use std::ops::{Add, Sub, Mul, Div, Neg};
Add, Sub, Mul, Div, Neg 分別表示加減乘除以及相反數(shù)，類似C++或者python語言中“重載運算符”的概念。
根據(jù)復(fù)數(shù)的運算法則，寫出對應(yīng)代碼：
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);
// 復(fù)數(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);
// 對比兩個復(fù)數(shù)是否相等
println!("{:?}", z1 == z2);
// 共軛復(fù)數(shù)
println!("{:?}", z2 == z3.conj());
// 復(fù)數(shù)的相反數(shù)
println!("{:?}", z2 == -z3.clone() + Complex::new(6.0,0.0));
// 復(fù)數(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
示例代碼中，同時還定義了復(fù)數(shù)的模 abs()，共軛復(fù)數(shù) conj()。
兩個復(fù)數(shù)的相等比較 z1 == z2，需要 #[derive(PartialEq)] 支持。
自定義 trait Display
復(fù)數(shù)結(jié)構(gòu)的原始 Debug trait 表達(dá)的輸出格式比較繁復(fù)，如：
Complex { real: 2.0, imag: 3.0 } + Complex { real: 3.0, imag: 4.0 } = Complex { real: 5.0, imag: 7.0 }
想要輸出和數(shù)學(xué)中相同的表達(dá)(如 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ù)和負(fù)數(shù)。另外當(dāng)虛部絕對值為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);
// 復(fù)數(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);
// 對比兩個復(fù)數(shù)是否相等
println!("{:?}", z1 == z2);
// 共軛復(fù)數(shù)
println!("{:?}", z2 == z3.conj());
// 復(fù)數(shù)的相反數(shù)
println!("{:?}", z2 == -z3.clone() + Complex::new(6.0,0.0));
// 復(fù)數(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
小結(jié)
如此，復(fù)數(shù)的四則運算基本都實現(xiàn)了，當(dāng)然復(fù)數(shù)還有三角表示式和指數(shù)表示式，根據(jù)它們的數(shù)學(xué)定義寫出相當(dāng)代碼應(yīng)該不是很難。有了復(fù)數(shù)三角式，就能方便地定義出復(fù)數(shù)的開方運算，有空可以寫寫這方面的代碼。
到此這篇關(guān)于Rust重載運算符之復(fù)數(shù)四則運算的實現(xiàn)的文章就介紹到這了,更多相關(guān)Rust運算符內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
這篇文章主要為大家詳細(xì)介紹了Rust語言中引用與借用的使用，文中的示例代碼講解詳細(xì)，具有一定的借鑒價值，需要的小伙伴可以了解一下2022-11-11
在 Rust 中,into() 方法通常用于將一個類型的值轉(zhuǎn)換為另一個類型,這通常涉及到資源的所有權(quán)轉(zhuǎn)移,本文給大家介紹Rust 語言中的 into() 方法及代碼實例,感謝的朋友跟隨小編一起看看吧2024-03-03
這篇文章主要介紹了如何用Rust打印hello world,本文分步驟通過圖文并茂的形式給大家講解的非常詳細(xì),對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2023-09-09
Rust是一種現(xiàn)代的系統(tǒng)編程語言，它支持函數(shù)指針。函數(shù)指針是指向函數(shù)的指針，可以將函數(shù)作為參數(shù)傳遞給其他函數(shù)或存儲在變量中。Rust中的函數(shù)指針可以用于實現(xiàn)回調(diào)函數(shù)、動態(tài)分發(fā)和多態(tài)等功能。本文將介紹Rust中的函數(shù)指針的基本用法和高級用法。2023-05-05
Rust和C++同樣也有vector概念,本文主要介紹了Rust中vector的詳細(xì)用法,文中通過示例代碼介紹的非常詳細(xì),對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值,需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2024-03-03
Rust可迭代類型迭代器正確創(chuàng)建自定義可迭代類型的方法
在 Rust 中, 如果一個類型實現(xiàn)了 Iterator, 那么它會被同時實現(xiàn) IntoIterator, 具體邏輯是返回自身, 因為自身就是迭代器,這篇文章主要介紹了Rust可迭代類型迭代器正確創(chuàng)建自定義可迭代類型的方法,需要的朋友可以參考下2023-12-12
Rust數(shù)據(jù)類型之結(jié)構(gòu)體Struct的使用
結(jié)構(gòu)體是Rust中非常強大和靈活的數(shù)據(jù)結(jié)構(gòu),可以用于組織和操作各種類型的數(shù)據(jù),本文就來介紹一下Rust數(shù)據(jù)類型之結(jié)構(gòu)體Struct的使用,感興趣的可以了解一下2023-12-12
本文介紹了Rust錯誤處理模型,重點講解了Result類型、自定義錯誤、錯誤傳播與轉(zhuǎn)換、錯誤鏈等概念,并以文件操作、網(wǎng)絡(luò)請求、數(shù)據(jù)庫操作為例展示了其實戰(zhàn)應(yīng)用,最后總結(jié)了最佳實踐,通過學(xué)習(xí),可以編寫更加健壯、可維護(hù)的代碼,感興趣的朋友一起看看吧2026-04-04
要開始在 Rust 中使用 JSON,您需要安裝一個可以輕松操作 JSON 的庫,目前可用的流行crate之一是 serde-json,在本文中,我們將討論如何在 Rust 中使用 JSON 解析庫,以及比較最流行的庫及其性能2024-03-03
Rust搭建webserver的底層原理與應(yīng)用實戰(zhàn)技巧
本文介紹Rust在HTTP編程中的應(yīng)用,涵蓋協(xié)議基礎(chǔ)、標(biāo)準(zhǔn)庫與第三方庫（如hyper、reqwest）的使用,以及多線程服務(wù)器和線程池的實現(xiàn)與關(guān)閉機制,展示Rust在性能、安全和并發(fā)方面的優(yōu)勢,感興趣的朋友跟隨小編一起看看吧2025-06-06