Generics 如何使用Float特性访问数值常量？

我想用Rust编写通用数学代码。类型

f32

和

f64

已经定义了常量。例如，π是

std:：f32:：consts:：PI

我知道

Float

trait提供了常见的函数，但是常量呢

我的尝试：

extern crate num;

use self::num::traits::Float;

fn f<T: Float>(t: T) -> T { 
    T::consts::PI * t 
}   

fn main() {
    let x = 5.0f32;
    println!("Result: {}", f(x));
}   

如果这是不可能的，那么如何使用泛型类型

T

？

访问数学常数这是一个称为关联常数的功能。num 0.1.41似乎没有使用任何此类常量，但您可以像下面这样扩展

Float

特性：

extern crate num;

trait FloatConst: num::Float {
    const PI: Self;
    const E: Self;
}

impl FloatConst for f32 {
    const PI: f32 = 3.14;
    const E: f32 = 2.71;
}

impl FloatConst for f64 {
    const PI: f64 = 3.14159;
    const E: f64 = 2.71828;
}

fn f<T: FloatConst>(t: T) -> T {
    t + T::PI + T::E
}

fn main() {
    let x = 5.0f32;
    println!("Result: {}", f(x));
}

extern板条箱数量；
trait FloatConst:num:：Float{
常数PI:Self；
常数：自我；
}
f32的impl FloatConst{
常数PI:f32=3.14；
常数E:f32=2.71；
}
f64的impl FloatConst{
常数PI:f64=3.14159；
常数E:f64=2.71828；
}
fn f（t:t）->t{
t+t:：PI+t:：E
}
fn main（）{
设x=5.0f32；
println！（（“结果：{}”，f（x））；
}

在Rust的早期版本中，您需要使用以下功能：

extern crate num;

use num::traits::Float;

trait FloatConst {
    fn pi() -> Self;
}

impl FloatConst for f32 {
    fn pi() -> Self { std::f32::consts::PI }
}

impl FloatConst for f64 {
    fn pi() -> Self { std::f64::consts::PI }
}

fn f<T: Float + FloatConst>(t: T) -> T {
    T::pi() * t
}

fn main() {
    println!("Result: {}", f(5.0f32));
    println!("Result: {}", f(5.0f64));
}

extern板条箱数量；
使用num:：traits:：Float；
特征常数{
fn-pi（）->Self；
}
f32的impl FloatConst{
fn pi（）->Self{std:：f32:：consts:：pi}
}
f64的impl FloatConst{
fn pi（）->Self{std:：f64:：consts:：pi}
}
fn f（t:t）->t{
T:：pi（）*T
}
fn main（）{
println！（“结果：{}”，f（5.0f32））；
println！（“结果：{}”，f（5.0f64））；
}

---

我希望单组化和编译器优化将使这一过程尽可能快，但如果需要，分析总是一个好主意。

注意

std:：f32

和

std:：f64

都是模块。它们与基本类型

f32

和

f64

不同。模块的命名如下，以明确它们与基元类型相关。

extern crate num;

use num::traits::Float;

trait FloatConst {
    fn pi() -> Self;
}

impl FloatConst for f32 {
    fn pi() -> Self { std::f32::consts::PI }
}

impl FloatConst for f64 {
    fn pi() -> Self { std::f64::consts::PI }
}

fn f<T: Float + FloatConst>(t: T) -> T {
    T::pi() * t
}

fn main() {
    println!("Result: {}", f(5.0f32));
    println!("Result: {}", f(5.0f64));
}