Rust 中的 const 除以泛型

我有一个结构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())
    }
}

错误：类型不匹配：预期_, found T（预期的浮点变量，找到的类型参数）

Type of 1.0 is _而类型为(*self % *self).sqrt() is T。而且似乎不能将 _ 除以 T。

我尝试了 1.0 的各种铸造：

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

错误：非标量转换：_ as T

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

错误：类型不匹配：预期&_, found T（预期的 &-ptr，找到的类型参数）

实现此方法的最简单方法是什么？

Edit 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 for f32 and f64

文字只能是原始类型。您无法将文字转换为某种泛型类型。

对于像这样的常数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() method:

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

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

Update

您很可能无法实施Float对于您的结构，因为它有很多特定于裸浮点数的方法，例如尾数大小。我想你必须添加类似的方法one() and zero()并可能自己根据数字进行转换。然后你就可以写

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