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())

错误：非标量演员：_为T

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

错误：类型不匹配：预期&_，找到T（预期＆amp; -ptr，找到类型参数）

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

编辑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);

顺便说一下，你可能会发现this accepted 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())
    }
}

在Rust中将const除以泛型

1 个答案: