rust From和Into traits以及usize到f64的转换

qjp7pelc  于 2023-03-30  发布在  其他
关注(0)|答案(2)|浏览(211)

我一直在尝试以一种非常通用的方式编写一些Rust代码,而没有显式地指定类型。然而,我到达了一个需要将usize转换为f64的点,这不起作用。据推测,f64没有足够的精度来保存任意的usize值。当在夜间通道上编译时,我得到一个错误消息:error: the traitcore::convert::Fromis not implemented for the typef64[E0277] .
那么,如果我想写尽可能通用的代码,还有什么选择呢?显然,我应该使用一个trait来进行可能失败的转换(不像IntoFrom)。已经有类似的东西了吗?有一个trait来实现as的转换吗?
下面是代码。

#![feature(zero_one)]
use std::num::{Zero, One};
use std::ops::{Add, Mul, Div, Neg};
use std::convert::{From, Into};

/// Computes the reciprocal of a polynomial or of a truncation of a
/// series.
///
/// If the input is of length `n`, then this performs `n^2`
/// multiplications.  Therefore the complexity is `n^2` when the type
/// of the entries is bounded, but it can be larger if the type is
/// unbounded, as for BigInt's.
///
fn series_reciprocal<T>(a: &Vec<T>) -> Vec<T>
    where T: Zero + One + Add<Output=T> + Mul<Output=T> +
             Div<Output=T> + Neg<Output=T> + Copy {

    let mut res: Vec<T> = vec![T::zero(); a.len()];
    res[0] = T::one() / a[0];

    for i in 1..a.len() {
        res[i] = a.iter()
                  .skip(1)
                  .zip(res.iter())
                  .map(|(&a, &b)| a * b)
                  .fold(T::zero(), |a, b| a + b) / (-a[0]);
    }
    res
}

/// This computes the ratios `B_n/n!` for a range of values of `n`
/// where `B_n` are the Bernoulli numbers.  We use the formula
///
///    z/(e^z - 1) = \sum_{k=1}^\infty \frac {B_k}{k!} z^k.
///
/// To find the ratios we truncate the series
///
///    (e^z-1)/z = 1 + 1/(2!) z + 1/(3!) z^2 + ...
///
/// to the desired length and then compute the inverse.
///
fn bernoulli_over_factorial<T, U>(n: U) -> Vec<T>
    where
        U: Into<usize> + Copy,
        T: Zero + One + Add<Output=T> + Mul<Output=T> +
           Add<Output=T> + Div<Output=T> + Neg<Output=T> +
           Copy + From<usize> {
    let mut ans: Vec<T> = vec![T::zero(); n.into()];
    ans[0] = T::one();
    for k in 1..n.into() {
        ans[k] = ans[k - 1] / (k + 1).into();
    }
    series_reciprocal(&ans)
}

fn main() {
    let v = vec![1.0f32, 1.0f32];
    let inv = series_reciprocal(&v);
    println!("v = {:?}", v);
    println!("v^-1 = {:?}", inv);
    let bf = bernoulli_over_factorial::<f64,i8>(30i8);
}
eufgjt7s

eufgjt7s1#

您可以使用as执行此操作:

let num: f64 = 12 as f64 ;
lokaqttq

lokaqttq2#

问题是整数→浮点转换,其中浮点类型的大小与整数相同或小于整数,* 不能 * 保留所有值。因此usizef64在64位上失去精度。
这些类型的转换基本上是conv crate存在的理由,它定义了类型之间的许多易出错的转换(大多数是内置的数字类型)。这(截至10分钟前)包括isize/usizef32/f64
使用conv,您可以执行以下操作:

use conv::prelude::*;

...

where T: ValueFrom<usize> + ...

...
ans[k] = ans[k - 1] / (k + 1).value_as::<T>().unwrap();
...

披露:我就是那个箱子的作者。

相关问题