Question

更新：此错误已由https://github.com/rust-lang/rust/pull/23673修复。下面的代码现在有效。

在数学和数值编程中，预计复数与实数（浮点）值无缝互操作。在Rust中是否可以定义struct Complex<T: Float>，允许涉及类型为T的值的对称数学运算？

例如，可以为输入*和(Complex<T>, Complex<T>)定义运算符(Complex<T>, T)，如下所示：

use std::ops::Mul;
use std::num::Float;

#[derive(Copy, Debug)]
pub struct Complex<T: Float> {
    pub re: T, pub im: T
}

impl<T: Float> Complex<T> {
    pub fn new(re: T, im: T) -> Complex<T> {
        Complex { re: re, im: im }
    }
}

impl<T: Float> Mul<Complex<T>> for Complex<T> {
    type Output = Complex<T>;

    fn mul(self, other: Complex<T>) -> Complex<T> {
        Complex::new(self.re * other.re - self.im * other.im,
                     self.re * other.im + self.im * other.re)
    }
}

impl<T: Float> Mul<T> for Complex<T> {
    type Output = Complex<T>;

    fn mul(self, other: T) -> Complex<T> {
        Complex::new(self.re * other, self.im * other)
    }
}

是否可以重载*以处理输入(T, Complex<T>)？例如，以下无法工作：

impl Mul<Complex<f64>> for f64 {
    type Output = Complex<f64>;
    fn mul(self, other: Complex<f64>) -> Complex<f64> {
        Complex::new(self * other.re, self * other.im)
    }
}

fn main() {
    let x = Complex::new(1.0, 1.0);
    let y = x*x;
    let z = x*4.0;
    let w = 4.0*x;
}

我收到错误消息：

 error: mismatched types:
 expected `_`,
    found `Complex<_>`
(expected floating-point variable,
    found struct `Complex`) [E0308]
src/main.rs:61     let w = 4.0*x;
                           ^

在Scala中，可以通过从T到Complex<T>的隐式转换来解决此问题。 Rust中有类似的技巧吗？有没有更好的方法来定义有效的，通用的*操作？感谢。

Answer 1

这应该被允许，但是outstanding issue会阻止在左侧使用内置类型（u8，f32等）自定义实现正在进行中的操作。

现在建议的解决方法是将自定义类型放在左侧，将内置类型放在右侧。

涉及复杂值和浮点值的运算符重载

1 个答案: