Generics 实现泛型类型的均值函数

我试图编写一个函数来返回

向量的平均值。我希望它能与泛型类型一起工作，但我在实现它时遇到了一些困难

extern crate num; // 0.2.0

use num::Zero;
use std::ops::{Add, Div};

pub struct Vector<T> {
    pub size: usize,
    pub data: Vec<T>,
}

impl<T: Copy + Zero + Add<T, Output = T>> Vector<T> {
    pub fn sum(&self) -> T {
        self.data.iter().fold(T::zero(), |sum, &val| sum + val)
    }
}

impl<T: Copy + Zero + Add<T, Output = T> + Div<T, Output = T>> Vector<T> {
    pub fn mean(&self) -> T {
        let sum = self.sum();
        sum / self.data.len()
    }
}

我知道我可以将签名更改为：

impl<T: Copy + Zero + Add<T, Output = T> + Div<usize, Output = T>> Vector<T>

impl向量

它可以编译，但是对于Rust原语类型没有实现。我应该怎么做呢？
中定义的基元类型实现，以允许基元类型之间的转换，包括
usize
。我们可以在函数上添加一个
FromPrimitive
绑定，然后我们可以将
usize
转换为
T
：

extern crate num; // 0.2.0

use num::{FromPrimitive, Zero};
use std::ops::{Add, Div};

impl<T> Vector<T>
where
    T: Copy + Zero + Add<T, Output = T> + Div<T, Output = T> + FromPrimitive,
{
    pub fn mean(&self) -> T {
        let sum = self.sum();
        sum / FromPrimitive::from_usize(self.data.len()).unwrap()
    }
}

extern板条箱数量；//0.2.0
使用num:：{FromPrimitive，Zero}；
使用std:：ops:：{Add，Div}；
impl向量
哪里
T:Copy+Zero+Add+Div+FromPrimitive，
{
发布fn平均值（&self）->T{
设sum=self.sum（）；
sum/FromPrimitive:：from_usize（self.data.len（））.unwrap（）
}
}
在许多情况下，计算输入类型的平均值是没有意义的。例如，整数1和2的整数平均值为1。如果您希望能够获得任何迭代器值的平均值，这些值可以被视为
i64
，并获得作为
f64
的平均值，您可以使用和：

fn平均值（s:I）->f64
哪里
I:迭代器，
I：：项：进入，
{
让mut count=0；
让总数=s
.into_iter（）
.map（Into：：Into）
.检查（| |计数+=1）
.sum:：（）；
总计为f64/计为f64
}

一些例子：

use std::collections::VecDeque;

fn main() {
    let a: Vec<u16> = vec![1, 2, 3];
    let b: Vec<u32> = vec![1, 2, 3];
    let c: VecDeque<u16> = vec![1u16, 2, 3].into();

    let v = avg_iter(a.iter().cloned());
    println!("{}", v);
    let v = avg_iter(a);
    println!("{}", v);

    let v = avg_iter(b.iter().cloned());
    println!("{}", v);
    let v = avg_iter(b);
    println!("{}", v);

    let v = avg_iter(c.iter().cloned());
    println!("{}", v);
    let v = avg_iter(c);
    println!("{}", v);
}


使用std:：collections:：VecDeque；
fn main（）{
设a:Vec=Vec！[1,2,3]；
设b:Vec=Vec！[1,2,3]；
让c:VecDeque=vec！[1u16,2,3].into（）；
设v=avg_iter（a.iter（）.cloned（））；
println！（“{}”，v）；
设v=平均值（a）；
println！（“{}”，v）；
设v=avg_iter（b.iter（）.cloned（））；
println！（“{}”，v）；
设v=平均值（b）；
println！（“{}”，v）；
设v=avg_iter（c.iter（）.cloned（））；
println！（“{}”，v）；
设v=平均温度（c）；
println！（“{}”，v）；
}

use std::collections::VecDeque;

fn main() {
    let a: Vec<u16> = vec![1, 2, 3];
    let b: Vec<u32> = vec![1, 2, 3];
    let c: VecDeque<u16> = vec![1u16, 2, 3].into();

    let v = avg_iter(a.iter().cloned());
    println!("{}", v);
    let v = avg_iter(a);
    println!("{}", v);

    let v = avg_iter(b.iter().cloned());
    println!("{}", v);
    let v = avg_iter(b);
    println!("{}", v);

    let v = avg_iter(c.iter().cloned());
    println!("{}", v);
    let v = avg_iter(c);
    println!("{}", v);
}