Как использовать литералы чисел с плавающей запятой при использовании универсальных типов?

Question

Обычные литералы с плавающей точкой не работают:

extern crate num_traits;

use num_traits::float::Float;

fn scale_float<T: Float>(x: T) -> T {
    x * 0.54
}

fn main() {
    let a: f64 = scale_float(1.23);
}

error[E0308]: mismatched types
 --> src/main.rs:6:9
  |
6 |     x * 0.54
  |         ^^^^ expected type parameter, found floating-point variable
  |
  = note: expected type `T`
             found type `{float}`

Answer 1

Используйте FromPrimitive черту :

use num_traits::{cast::FromPrimitive, float::Float};

fn scale_float<T: Float + FromPrimitive>(x: T) -> T {
    x * T::from_f64(0.54).unwrap()
}

или стандартную библиотеку From / Into черты

fn scale_float<T>(x: T) -> T
where
    T: Float,
    f64: Into<T>
{
    x * 0.54.into()
}

См. Также:

• Как использовать числовые литералы с чертой Integer из ящика с числами?

Answer 2

В некоторых случаях вы можете добавить ограничение, согласно которому универсальный тип должен умножаться на тип литерала.Здесь мы разрешаем любой тип, который может быть умножен на f64, если он производит тип вывода T через ограниченную черту Mul<f64, Output = T>:

use num_traits::float::Float; // 0.2.6
use std::ops::Mul;

fn scale_float<T>(x: T) -> T
where
    T: Float + Mul<f64, Output = T>,
{
    x * 0.54
}

fn main() {
    let a: f64 = scale_float(1.23);
}

Это может не работать напрямую дляисходная проблема, но это может зависеть от того, с какими конкретными типами вам нужно работать.

Answer 3

Вы не можете создать Float из литерала напрямую.Я предлагаю подход, похожий на черту FloatConst:

trait SomeDomainSpecificScaleFactor {
    fn factor() -> Self;
}

impl SomeDomainSpecificScaleFactor for f32 {
    fn factor() -> Self {
        0.54
    }
}

impl SomeDomainSpecificScaleFactor for f64 {
    fn factor() -> Self {
        0.54
    }
}

fn scale_float<T: Float + SomeDomainSpecificScaleFactor>(x: T) -> T {
    x * T::factor()
}

( ссылка на игровую площадку )