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 substrate_fixed::traits::LossyFrom;
use substrate_fixed::types::{I12F4, I4F60};
// original is 0x1.234
let original = I4F60::from_bits(0x1234i64 << (60 - 12));
let lossy = I12F4::lossy_from(original);
assert_eq!(lossy, I12F4::from_bits(0x0012));

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 does not lose any precision, so it is actually lossless.

impl LossyFrom<bool> for i8

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for i16

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for i32

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for i64

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for i128

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for isize

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for u8

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for u16

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for u32

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for u64

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for u128

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for usize

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<f32> for f32

fn lossy_from(src: f32) -> Self

Converts a number.

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

impl LossyFrom<f32> for f64

fn lossy_from(src: f32) -> Self

Converts a number.

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

impl LossyFrom<f32> for bf16

fn lossy_from(src: f32) -> Self

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) -> Self

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) -> Self

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 does not lose any precision, so it is actually lossless.

impl LossyFrom<f64> for bf16

fn lossy_from(src: f64) -> Self

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) -> Self

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 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<i8> for i16

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<i8> for i32

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<i8> for i64

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<i8> for i128

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<i8> for isize

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<i8> for bf16

fn lossy_from(src: i8) -> 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) -> f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) and 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 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<i16> for i32

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<i16> for i64

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<i16> for i128

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<i16> for isize

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<i16> for bf16

fn lossy_from(src: i16) -> 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) -> 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<i32> for i64

fn lossy_from(src: i32) -> Self

Converts a number.

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

impl LossyFrom<i32> for i128

fn lossy_from(src: i32) -> Self

Converts a number.

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

impl LossyFrom<i32> for bf16

fn lossy_from(src: i32) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<i64> for i128

fn lossy_from(src: i64) -> Self

Converts a number.

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

impl LossyFrom<i64> for bf16

fn lossy_from(src: i64) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<i128> for bf16

fn lossy_from(src: i128) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<isize> for bf16

fn lossy_from(src: isize) -> 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) -> 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 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<u8> for i32

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for i64

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for i128

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for isize

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for u8

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for u16

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for u32

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for u64

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for u128

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for usize

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for bf16

fn lossy_from(src: u8) -> 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) -> f16

Converts an integer to a floating-point number.

This conversion never fails (infallible) and 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 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<u16> for i64

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for i128

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for u16

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for u32

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for u64

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for u128

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for usize

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u16> for bf16

fn lossy_from(src: u16) -> 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) -> 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 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<u32> for i128

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl LossyFrom<u32> for u32

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl LossyFrom<u32> for u64

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl LossyFrom<u32> for u128

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl LossyFrom<u32> for bf16

fn lossy_from(src: u32) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<u64> for u64

fn lossy_from(src: u64) -> Self

Converts a number.

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

impl LossyFrom<u64> for u128

fn lossy_from(src: u64) -> Self

Converts a number.

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

impl LossyFrom<u64> for bf16

fn lossy_from(src: u64) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<u128> for bf16

fn lossy_from(src: u128) -> 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) -> 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 does not lose any precision, so it is actually lossless.

impl LossyFrom<usize> for bf16

fn lossy_from(src: usize) -> 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) -> 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: bf16) -> Self

Converts a number.

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

impl LossyFrom<bf16> for f64

fn lossy_from(src: bf16) -> Self

Converts a number.

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

impl LossyFrom<bf16> for bf16

fn lossy_from(src: bf16) -> Self

Converts a number.

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

impl LossyFrom<bf16> for f16

fn lossy_from(src: bf16) -> 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: f16) -> Self

Converts a number.

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

impl LossyFrom<f16> for f64

fn lossy_from(src: f16) -> Self

Converts a number.

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

impl LossyFrom<f16> for bf16

fn lossy_from(src: f16) -> 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: f16) -> Self

Converts a number.

This conversion never fails (infallible) and does not lose any precision, so it is actually 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 bf16

fn lossy_from(src: FixedI8<Frac>) -> 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 f16

fn lossy_from(src: FixedI8<Frac>) -> 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 bf16

fn lossy_from(src: FixedU8<Frac>) -> 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 f16

fn lossy_from(src: FixedU8<Frac>) -> 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 bf16

fn lossy_from(src: FixedI16<Frac>) -> 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 f16

fn lossy_from(src: FixedI16<Frac>) -> 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 bf16

fn lossy_from(src: FixedU16<Frac>) -> 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 f16

fn lossy_from(src: FixedU16<Frac>) -> 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 bf16

fn lossy_from(src: FixedI32<Frac>) -> 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 f16

fn lossy_from(src: FixedI32<Frac>) -> 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 bf16

fn lossy_from(src: FixedU32<Frac>) -> 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 f16

fn lossy_from(src: FixedU32<Frac>) -> 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 bf16

fn lossy_from(src: FixedI64<Frac>) -> 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 f16

fn lossy_from(src: FixedI64<Frac>) -> 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 bf16

fn lossy_from(src: FixedU64<Frac>) -> 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 f16

fn lossy_from(src: FixedU64<Frac>) -> 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 bf16

fn lossy_from(src: FixedI128<Frac>) -> 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 f16

fn lossy_from(src: FixedI128<Frac>) -> 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 bf16

fn lossy_from(src: FixedU128<Frac>) -> 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 f16

fn lossy_from(src: FixedU128<Frac>) -> 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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

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 truncated.

Implementors

impl LossyFrom<i8> for FixedI8<U0>

impl LossyFrom<i16> for FixedI16<U0>

impl LossyFrom<i32> for FixedI32<U0>

impl LossyFrom<i64> for FixedI64<U0>

impl LossyFrom<i128> for FixedI128<U0>

impl LossyFrom<u8> for FixedU8<U0>

impl LossyFrom<u16> for FixedU16<U0>

impl LossyFrom<u32> for FixedU32<U0>

impl LossyFrom<u64> for FixedU64<U0>

impl LossyFrom<u128> for FixedU128<U0>

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>,