Trait LossyFrom 

pub trait LossyFrom<Src> {
    // Required method
    fn lossy_from(src: Src) -> Self;
}

This trait provides infallible conversions that might be lossy.

This trait is implemented for conversions between integer primitives, floating-point primitives and fixed-point numbers.

Examples

use fixed::traits::LossyFrom;
use fixed::types::{I12F4, I8F24};
// original is 0x12.345678, lossy is 0x012.3
let original = I8F24::from_bits(0x1234_5678);
let lossy = I12F4::lossy_from(original);
assert_eq!(lossy, I12F4::from_bits(0x0123));

Required Methods

fn lossy_from(src: Src) -> Self

Performs the conversion.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl LossyFrom<bool> for bool

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for i8

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for i16

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for i32

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for i64

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for i128

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for isize

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for u8

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for u16

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for u32

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for u64

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for u128

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bool> for usize

fn lossy_from(src: bool) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f32> for f32

fn lossy_from(src: f32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f32> for f64

fn lossy_from(src: f32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f32> for bf16

fn lossy_from(src: f32) -> half_bf16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f32> for f16

fn lossy_from(src: f32) -> half_f16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f64> for f32

fn lossy_from(src: f64) -> f32

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f64> for f64

fn lossy_from(src: f64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f64> for bf16

fn lossy_from(src: f64) -> half_bf16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f64> for f16

fn lossy_from(src: f64) -> half_f16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i8> for f32

fn lossy_from(src: i8) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i8> for f64

fn lossy_from(src: i8) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i8> for i8

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for i16

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for i32

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for i64

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for i128

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for isize

fn lossy_from(src: i8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i8> for bf16

fn lossy_from(src: i8) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i8> for f16

fn lossy_from(src: i8) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i16> for f32

fn lossy_from(src: i16) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i16> for f64

fn lossy_from(src: i16) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i16> for i16

fn lossy_from(src: i16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i16> for i32

fn lossy_from(src: i16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i16> for i64

fn lossy_from(src: i16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i16> for i128

fn lossy_from(src: i16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i16> for isize

fn lossy_from(src: i16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i16> for bf16

fn lossy_from(src: i16) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i16> for f16

fn lossy_from(src: i16) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i32> for f32

fn lossy_from(src: i32) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i32> for f64

fn lossy_from(src: i32) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<i32> for i32

fn lossy_from(src: i32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i32> for i64

fn lossy_from(src: i32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i32> for i128

fn lossy_from(src: i32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i32> for bf16

fn lossy_from(src: i32) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i32> for f16

fn lossy_from(src: i32) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i64> for f32

fn lossy_from(src: i64) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i64> for f64

fn lossy_from(src: i64) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i64> for i64

fn lossy_from(src: i64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i64> for i128

fn lossy_from(src: i64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i64> for bf16

fn lossy_from(src: i64) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i64> for f16

fn lossy_from(src: i64) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i128> for f32

fn lossy_from(src: i128) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i128> for f64

fn lossy_from(src: i128) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i128> for i128

fn lossy_from(src: i128) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<i128> for bf16

fn lossy_from(src: i128) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<i128> for f16

fn lossy_from(src: i128) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<isize> for f32

fn lossy_from(src: isize) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<isize> for f64

fn lossy_from(src: isize) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<isize> for isize

fn lossy_from(src: isize) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<isize> for bf16

fn lossy_from(src: isize) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<isize> for f16

fn lossy_from(src: isize) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u8> for f32

fn lossy_from(src: u8) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u8> for f64

fn lossy_from(src: u8) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u8> for i16

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for i32

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for i64

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for i128

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for isize

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for u8

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for u16

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for u32

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for u64

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for u128

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for usize

fn lossy_from(src: u8) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u8> for bf16

fn lossy_from(src: u8) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u8> for f16

fn lossy_from(src: u8) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u16> for f32

fn lossy_from(src: u16) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u16> for f64

fn lossy_from(src: u16) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u16> for i32

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for i64

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for i128

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for u16

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for u32

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for u64

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for u128

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for usize

fn lossy_from(src: u16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u16> for bf16

fn lossy_from(src: u16) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u16> for f16

fn lossy_from(src: u16) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u32> for f32

fn lossy_from(src: u32) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u32> for f64

fn lossy_from(src: u32) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) and actually does not lose precision (lossless).

impl LossyFrom<u32> for i64

fn lossy_from(src: u32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u32> for i128

fn lossy_from(src: u32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u32> for u32

fn lossy_from(src: u32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u32> for u64

fn lossy_from(src: u32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u32> for u128

fn lossy_from(src: u32) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u32> for bf16

fn lossy_from(src: u32) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u32> for f16

fn lossy_from(src: u32) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u64> for f32

fn lossy_from(src: u64) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u64> for f64

fn lossy_from(src: u64) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u64> for i128

fn lossy_from(src: u64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u64> for u64

fn lossy_from(src: u64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u64> for u128

fn lossy_from(src: u64) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u64> for bf16

fn lossy_from(src: u64) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u64> for f16

fn lossy_from(src: u64) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u128> for f32

fn lossy_from(src: u128) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u128> for f64

fn lossy_from(src: u128) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u128> for u128

fn lossy_from(src: u128) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<u128> for bf16

fn lossy_from(src: u128) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<u128> for f16

fn lossy_from(src: u128) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<usize> for f32

fn lossy_from(src: usize) -> f32

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<usize> for f64

fn lossy_from(src: usize) -> f64

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<usize> for usize

fn lossy_from(src: usize) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<usize> for bf16

fn lossy_from(src: usize) -> half_bf16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<usize> for f16

fn lossy_from(src: usize) -> half_f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<bf16> for f32

fn lossy_from(src: half_bf16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bf16> for f64

fn lossy_from(src: half_bf16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bf16> for bf16

fn lossy_from(src: half_bf16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<bf16> for f16

fn lossy_from(src: half_bf16) -> half_f16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f16> for f32

fn lossy_from(src: half_f16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f16> for f64

fn lossy_from(src: half_f16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl LossyFrom<f16> for bf16

fn lossy_from(src: half_f16) -> half_bf16

Converts a number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl LossyFrom<f16> for f16

fn lossy_from(src: half_f16) -> Self

Converts a number.

This conversion never fails (infallible) and actually does not lose any precision (lossless).

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for f32

fn lossy_from(src: FixedI8<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for f64

fn lossy_from(src: FixedI8<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for half_bf16

fn lossy_from(src: FixedI8<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for half_f16

fn lossy_from(src: FixedI8<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for f32

fn lossy_from(src: FixedU8<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for f64

fn lossy_from(src: FixedU8<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for half_bf16

fn lossy_from(src: FixedU8<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for half_f16

fn lossy_from(src: FixedU8<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for f32

fn lossy_from(src: FixedI16<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for f64

fn lossy_from(src: FixedI16<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for half_bf16

fn lossy_from(src: FixedI16<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for half_f16

fn lossy_from(src: FixedI16<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for f32

fn lossy_from(src: FixedU16<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for f64

fn lossy_from(src: FixedU16<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for half_bf16

fn lossy_from(src: FixedU16<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for half_f16

fn lossy_from(src: FixedU16<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f32

fn lossy_from(src: FixedI32<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f64

fn lossy_from(src: FixedI32<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for half_bf16

fn lossy_from(src: FixedI32<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for half_f16

fn lossy_from(src: FixedI32<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for f32

fn lossy_from(src: FixedU32<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for f64

fn lossy_from(src: FixedU32<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for half_bf16

fn lossy_from(src: FixedU32<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for half_f16

fn lossy_from(src: FixedU32<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f32

fn lossy_from(src: FixedI64<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f64

fn lossy_from(src: FixedI64<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for half_bf16

fn lossy_from(src: FixedI64<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for half_f16

fn lossy_from(src: FixedI64<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for f32

fn lossy_from(src: FixedU64<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for f64

fn lossy_from(src: FixedU64<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for half_bf16

fn lossy_from(src: FixedU64<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for half_f16

fn lossy_from(src: FixedU64<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f32

fn lossy_from(src: FixedI128<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f64

fn lossy_from(src: FixedI128<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for half_bf16

fn lossy_from(src: FixedI128<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for half_f16

fn lossy_from(src: FixedI128<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for f32

fn lossy_from(src: FixedU128<Frac>) -> f32

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for f64

fn lossy_from(src: FixedU128<Frac>) -> f64

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for half_bf16

fn lossy_from(src: FixedU128<Frac>) -> half_bf16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for half_f16

fn lossy_from(src: FixedU128<Frac>) -> half_f16

Converts a fixed-point number to a floating-point number.

This conversion never fails (infallible) but may lose precision (lossy). Rounding is to the nearest, with ties rounded to even.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i8

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i16

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i32

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i64

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i128

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for isize

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i8

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U7, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i16

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i32

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U31, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i64

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U63, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i128

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U127, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for isize

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u8

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u16

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u32

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u64

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u128

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for usize

where U8: Sub<FracSrc>, Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU8<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i8

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i16

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i32

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i64

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i128

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for isize

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i8

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U7, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i16

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i32

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U31, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i64

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U63, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i128

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U127, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for isize

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u8

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u16

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u32

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u64

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u128

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for usize

where U16: Sub<FracSrc>, Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU16<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i8

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i16

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i32

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i64

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i128

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for isize

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i8

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U7, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i16

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i32

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U31, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i64

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U63, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i128

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U127, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for isize

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u8

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u16

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u32

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u64

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u128

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for usize

where U32: Sub<FracSrc>, Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU32<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i8

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i16

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i32

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i64

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i128

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for isize

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i8

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U7, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i16

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i32

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U31, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i64

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U63, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i128

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U127, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for isize

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u8

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u16

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u32

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u64

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u128

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for usize

where U64: Sub<FracSrc>, Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU64<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i8

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i16

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i32

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i64

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i128

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for isize

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedI128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i8

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U7, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i16

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i32

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U31, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i64

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U63, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i128

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U127, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for isize

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U15, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u8

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U8, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u16

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u32

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U32, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u64

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U64, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u128

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U128, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for usize

where U128: Sub<FracSrc>, Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>,

fn lossy_from(src: FixedU128<FracSrc>) -> Self

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any fractional bits in the source are discarded, which rounds towards −∞.

Implementors

impl LossyFrom<i8> for F128

impl LossyFrom<i8> for F128Bits

impl LossyFrom<i8> for FixedI8<U0>

impl LossyFrom<i16> for F128

impl LossyFrom<i16> for F128Bits

impl LossyFrom<i16> for FixedI16<U0>

impl LossyFrom<i32> for F128

impl LossyFrom<i32> for F128Bits

impl LossyFrom<i32> for FixedI32<U0>

impl LossyFrom<i64> for F128

impl LossyFrom<i64> for F128Bits

impl LossyFrom<i64> for FixedI64<U0>

impl LossyFrom<i128> for F128

impl LossyFrom<i128> for F128Bits

impl LossyFrom<i128> for FixedI128<U0>

impl LossyFrom<isize> for F128

impl LossyFrom<isize> for F128Bits

impl LossyFrom<u8> for F128

impl LossyFrom<u8> for F128Bits

impl LossyFrom<u8> for FixedU8<U0>

impl LossyFrom<u16> for F128

impl LossyFrom<u16> for F128Bits

impl LossyFrom<u16> for FixedU16<U0>

impl LossyFrom<u32> for F128

impl LossyFrom<u32> for F128Bits

impl LossyFrom<u32> for FixedU32<U0>

impl LossyFrom<u64> for F128

impl LossyFrom<u64> for F128Bits

impl LossyFrom<u64> for FixedU64<U0>

impl LossyFrom<u128> for F128

impl LossyFrom<u128> for F128Bits

impl LossyFrom<u128> for FixedU128<U0>

impl LossyFrom<usize> for F128

impl LossyFrom<usize> for F128Bits

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for F128

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for F128Bits

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for F128

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for F128Bits

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for F128

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for F128Bits

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for F128

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for F128Bits

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for F128

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for F128Bits

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for F128

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for F128Bits

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for F128

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for F128Bits

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for F128

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for F128Bits

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for F128

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for F128Bits

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for F128

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for F128Bits

impl<FracDst: LeEqU8> LossyFrom<bool> for FixedI8<FracDst>

where U7: Sub<FracDst>, U1: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracDst: LeEqU8> LossyFrom<bool> for FixedU8<FracDst>

where U8: Sub<FracDst>, U1: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracDst: LeEqU16> LossyFrom<bool> for FixedI16<FracDst>

where U15: Sub<FracDst>, U1: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracDst: LeEqU16> LossyFrom<bool> for FixedU16<FracDst>

where U16: Sub<FracDst>, U1: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracDst: LeEqU16> LossyFrom<i8> for FixedI16<FracDst>

where U16: Sub<FracDst>, U8: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracDst: LeEqU16> LossyFrom<u8> for FixedI16<FracDst>

where U15: Sub<FracDst>, U8: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracDst: LeEqU16> LossyFrom<u8> for FixedU16<FracDst>

where U16: Sub<FracDst>, U8: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<bool> for FixedI32<FracDst>

where U31: Sub<FracDst>, U1: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<bool> for FixedU32<FracDst>

where U32: Sub<FracDst>, U1: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<i8> for FixedI32<FracDst>

where U32: Sub<FracDst>, U8: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<i16> for FixedI32<FracDst>

where U32: Sub<FracDst>, U16: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<u8> for FixedI32<FracDst>

where U31: Sub<FracDst>, U8: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<u8> for FixedU32<FracDst>

where U32: Sub<FracDst>, U8: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<u16> for FixedI32<FracDst>

where U31: Sub<FracDst>, U16: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracDst: LeEqU32> LossyFrom<u16> for FixedU32<FracDst>

where U32: Sub<FracDst>, U16: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<bool> for FixedI64<FracDst>

where U63: Sub<FracDst>, U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<bool> for FixedU64<FracDst>

where U64: Sub<FracDst>, U1: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<i8> for FixedI64<FracDst>

where U64: Sub<FracDst>, U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<i16> for FixedI64<FracDst>

where U64: Sub<FracDst>, U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<i32> for FixedI64<FracDst>

where U64: Sub<FracDst>, U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u8> for FixedI64<FracDst>

where U63: Sub<FracDst>, U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u8> for FixedU64<FracDst>

where U64: Sub<FracDst>, U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u16> for FixedI64<FracDst>

where U63: Sub<FracDst>, U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u16> for FixedU64<FracDst>

where U64: Sub<FracDst>, U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u32> for FixedI64<FracDst>

where U63: Sub<FracDst>, U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracDst: LeEqU64> LossyFrom<u32> for FixedU64<FracDst>

where U64: Sub<FracDst>, U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<bool> for FixedI128<FracDst>

where U127: Sub<FracDst>, U1: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<bool> for FixedU128<FracDst>

where U128: Sub<FracDst>, U1: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<i8> for FixedI128<FracDst>

where U128: Sub<FracDst>, U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<i16> for FixedI128<FracDst>

where U128: Sub<FracDst>, U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<i32> for FixedI128<FracDst>

where U128: Sub<FracDst>, U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<i64> for FixedI128<FracDst>

where U128: Sub<FracDst>, U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u8> for FixedI128<FracDst>

where U127: Sub<FracDst>, U8: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u8> for FixedU128<FracDst>

where U128: Sub<FracDst>, U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u16> for FixedI128<FracDst>

where U127: Sub<FracDst>, U16: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u16> for FixedU128<FracDst>

where U128: Sub<FracDst>, U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u32> for FixedI128<FracDst>

where U127: Sub<FracDst>, U32: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u32> for FixedU128<FracDst>

where U128: Sub<FracDst>, U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u64> for FixedI128<FracDst>

where U127: Sub<FracDst>, U64: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracDst: LeEqU128> LossyFrom<u64> for FixedU128<FracDst>

where U128: Sub<FracDst>, U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedI8<FracSrc>> for FixedI8<FracDst>

where U8: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedU8<FracSrc>> for FixedI8<FracDst>

where U8: Sub<FracSrc>, U7: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedU8<FracSrc>> for FixedU8<FracDst>

where U8: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedI8<FracSrc>> for FixedI16<FracDst>

where U8: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedU8<FracSrc>> for FixedI16<FracDst>

where U8: Sub<FracSrc>, U15: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedU8<FracSrc>> for FixedU16<FracDst>

where U8: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedI8<FracSrc>> for FixedI32<FracDst>

where U8: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedU8<FracSrc>> for FixedI32<FracDst>

where U8: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedU8<FracSrc>> for FixedU32<FracDst>

where U8: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedI8<FracSrc>> for FixedI64<FracDst>

where U8: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedU8<FracSrc>> for FixedI64<FracDst>

where U8: Sub<FracSrc>, U63: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedU8<FracSrc>> for FixedU64<FracDst>

where U8: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedI8<FracSrc>> for FixedI128<FracDst>

where U8: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedU8<FracSrc>> for FixedI128<FracDst>

where U8: Sub<FracSrc>, U127: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedU8<FracSrc>> for FixedU128<FracDst>

where U8: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedI16<FracSrc>> for FixedI8<FracDst>

where U16: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedU16<FracSrc>> for FixedI8<FracDst>

where U16: Sub<FracSrc>, U7: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedU16<FracSrc>> for FixedU8<FracDst>

where U16: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedI16<FracSrc>> for FixedI16<FracDst>

where U16: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedU16<FracSrc>> for FixedI16<FracDst>

where U16: Sub<FracSrc>, U15: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedU16<FracSrc>> for FixedU16<FracDst>

where U16: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedI16<FracSrc>> for FixedI32<FracDst>

where U16: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedU16<FracSrc>> for FixedI32<FracDst>

where U16: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedU16<FracSrc>> for FixedU32<FracDst>

where U16: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedI16<FracSrc>> for FixedI64<FracDst>

where U16: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedU16<FracSrc>> for FixedI64<FracDst>

where U16: Sub<FracSrc>, U63: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedU16<FracSrc>> for FixedU64<FracDst>

where U16: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedI16<FracSrc>> for FixedI128<FracDst>

where U16: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedU16<FracSrc>> for FixedI128<FracDst>

where U16: Sub<FracSrc>, U127: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedU16<FracSrc>> for FixedU128<FracDst>

where U16: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedI32<FracSrc>> for FixedI8<FracDst>

where U32: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedU32<FracSrc>> for FixedI8<FracDst>

where U32: Sub<FracSrc>, U7: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedU32<FracSrc>> for FixedU8<FracDst>

where U32: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedI32<FracSrc>> for FixedI16<FracDst>

where U32: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedU32<FracSrc>> for FixedI16<FracDst>

where U32: Sub<FracSrc>, U15: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedU32<FracSrc>> for FixedU16<FracDst>

where U32: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedI32<FracSrc>> for FixedI32<FracDst>

where U32: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedU32<FracSrc>> for FixedI32<FracDst>

where U32: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedU32<FracSrc>> for FixedU32<FracDst>

where U32: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedI32<FracSrc>> for FixedI64<FracDst>

where U32: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedU32<FracSrc>> for FixedI64<FracDst>

where U32: Sub<FracSrc>, U63: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedU32<FracSrc>> for FixedU64<FracDst>

where U32: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedI32<FracSrc>> for FixedI128<FracDst>

where U32: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedU32<FracSrc>> for FixedI128<FracDst>

where U32: Sub<FracSrc>, U127: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedU32<FracSrc>> for FixedU128<FracDst>

where U32: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedI64<FracSrc>> for FixedI8<FracDst>

where U64: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedU64<FracSrc>> for FixedI8<FracDst>

where U64: Sub<FracSrc>, U7: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedU64<FracSrc>> for FixedU8<FracDst>

where U64: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedI64<FracSrc>> for FixedI16<FracDst>

where U64: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedU64<FracSrc>> for FixedI16<FracDst>

where U64: Sub<FracSrc>, U15: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedU64<FracSrc>> for FixedU16<FracDst>

where U64: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedI64<FracSrc>> for FixedI32<FracDst>

where U64: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedU64<FracSrc>> for FixedI32<FracDst>

where U64: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedU64<FracSrc>> for FixedU32<FracDst>

where U64: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedI64<FracSrc>> for FixedI64<FracDst>

where U64: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedU64<FracSrc>> for FixedI64<FracDst>

where U64: Sub<FracSrc>, U63: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedU64<FracSrc>> for FixedU64<FracDst>

where U64: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedI64<FracSrc>> for FixedI128<FracDst>

where U64: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedU64<FracSrc>> for FixedI128<FracDst>

where U64: Sub<FracSrc>, U127: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedU64<FracSrc>> for FixedU128<FracDst>

where U64: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedI128<FracSrc>> for FixedI8<FracDst>

where U128: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedU128<FracSrc>> for FixedI8<FracDst>

where U128: Sub<FracSrc>, U7: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedU128<FracSrc>> for FixedU8<FracDst>

where U128: Sub<FracSrc>, U8: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedI128<FracSrc>> for FixedI16<FracDst>

where U128: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedU128<FracSrc>> for FixedI16<FracDst>

where U128: Sub<FracSrc>, U15: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedU128<FracSrc>> for FixedU16<FracDst>

where U128: Sub<FracSrc>, U16: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedI128<FracSrc>> for FixedI32<FracDst>

where U128: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedU128<FracSrc>> for FixedI32<FracDst>

where U128: Sub<FracSrc>, U31: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedU128<FracSrc>> for FixedU32<FracDst>

where U128: Sub<FracSrc>, U32: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedI128<FracSrc>> for FixedI64<FracDst>

where U128: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedU128<FracSrc>> for FixedI64<FracDst>

where U128: Sub<FracSrc>, U63: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedU128<FracSrc>> for FixedU64<FracDst>

where U128: Sub<FracSrc>, U64: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedI128<FracSrc>> for FixedI128<FracDst>

where U128: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedU128<FracSrc>> for FixedI128<FracDst>

where U128: Sub<FracSrc>, U127: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>,

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedU128<FracSrc>> for FixedU128<FracDst>

where U128: Sub<FracSrc>, U128: Sub<FracDst>, Diff<U128, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>,