除以锈迹中的通类

Question

我有一个结构Vec3<T>，如何实现以下方法？

impl<T: num::Num + num::Float> Not<Vec3<T>> for Vec3<T> {
    fn not(&self) -> Vec3<T> {
        *self * (1.0 / (*self % *self).sqrt())
    }
}

错误:不匹配类型:预期的_**，T (预期浮点变量，查找类型参数)

1.0类型为_，而(*self % *self).sqrt()类型为T。而且它似乎不能除以T。

我为1.0尝试了各种类型的铸造：

*self * ((1.0 as T) / (*self % *self).sqrt())

错误:非标量强制转换：_ as T

*self * (1.0.div((*self % *self).sqrt()))

错误:不匹配类型:预期的&_**，T **(预期&ptr，found参数)

实现这个方法的最巧妙的方法是什么？

编辑1:，这是我的完整代码：

use std::num::Float;

pub struct Vec3<T> {
    pub x: T,
    pub y: T,
    pub z: T,
}

impl<T> Vec3<T> {
    pub fn new(x: T, y: T, z: T) -> Vec3<T> {
        Vec3 { x: x, y: y, z: z }
    }
}

impl<T: Float> Add<T, Vec3<T>> for Vec3<T> {
    fn add(&self, rhs: &T) -> Vec3<T> {
        Vec3 { x: self.x + *rhs, y: self.y + *rhs, z: self.z + *rhs }
    }
}

impl<T: Float> Add<Vec3<T>, Vec3<T>> for Vec3<T> {
    fn add(&self, rhs: &Vec3<T>) -> Vec3<T> {
        Vec3 { x: self.x + rhs.x, y: self.y + rhs.y, z: self.z + rhs.z }
    }
}

impl<T: Float> Mul<T, Vec3<T>> for Vec3<T> {
    fn mul(&self, rhs: &T) -> Vec3<T> {
        Vec3 { x: self.x * *rhs, y: self.y * *rhs, z: self.z * *rhs }
    }
}

// x % y : dot-product
impl<T: Float> Rem<Vec3<T>, T> for Vec3<T> {
    fn rem(&self, rhs: &Vec3<T>) -> T {
        self.x + rhs.x * self.y + rhs.y * self.z + rhs.z
    }
}

// x ^ y : cross-product
impl<T: Float> BitXor<Vec3<T>, Vec3<T>> for Vec3<T> {
    fn bitxor(&self, rhs: &Vec3<T>) -> Vec3<T> {
        Vec3 { x: self.y * rhs.z - self.z * rhs.y,
               y: self.z * rhs.x - self.x * rhs.z,
               z: self.x * rhs.y - self.y * rhs.x }
    }
}

// !x : Norm
impl Not<Vec3<f32>> for Vec3<f32> {
    fn not(&self) -> Vec3<f32> {
        *self * (1.0f32 / (*self % *self).sqrt())
    }
}

impl Not<Vec3<f64>> for Vec3<f64> {
    fn not(&self) -> Vec3<f64> {
        *self * (1.0f64 / (*self % *self).sqrt())
    }
}

我本可以使用Num而不是Float来获得整数向量，但是由于不推荐使用它，我认为更好的选择是使用宏来复制所有类型的代码。在这里，我复制了Not的f32和f64

Answer 1

文字只能是原始类型的。不能将文字转换为某些泛型类型。

对于像1.0这样的常量，您可以使用像Float::one()这样的方法，因此您的特定示例可以重写为

impl<T: num::Float> Not<Vec3<T>> for Vec3<T> {
    fn not(&self) -> Vec3<T> {
        *self * (num::Float::one() / (*self % *self).sqrt())
    }
}

(请注意，我删除了Num绑定，因为它是不推荐的，在本例中，它完全被Float所取代)

要将任意值转换为某些特定Float类型的实例，可以使用NumCast::from()方法：

let x: T = num::NumCast::from(3.14f64);

顺便说一句，你可能会发现这是接受的RFC很有趣。

更新

您可能无法为您的结构实现Float，因为它有许多特定于裸浮点数的方法，比如尾数大小。我想您将不得不添加像one()和zero()这样的方法，并且可能需要自己从数字中进行转换。然后你就可以写了

impl<T: num::Float> Not<Vec3<T>> for Vec3<T> {
    fn not(&self) -> Vec3<T> {
        *self * (Vec3::one() / (*self % *self).sqrt())
    }
}