Trait fixed::traits::LosslessTryFrom

pub trait LosslessTryFrom<Src>: Sized {
    // Required method
    fn lossless_try_from(src: Src) -> Option<Self>;
}

This trait provides lossless conversions that might be fallible.

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

Examples

use fixed::traits::LosslessTryFrom;
use fixed::types::{I24F8, I4F12};
// original is 0x000001.23, lossless is 0x1.230
let original = I24F8::from_bits(0x0000_0123);
let lossless = I4F12::lossless_try_from(original);
assert_eq!(lossless, Some(I4F12::from_bits(0x1230)));
// too_large is 0x000012.34, 0x12.340 does not fit in I4F12
let too_large = I24F8::from_bits(0x0000_1234);
let overflow = I4F12::lossless_try_from(too_large);
assert_eq!(overflow, None);

Required Methods

fn lossless_try_from(src: Src) -> Option<Self>

Performs the conversion.

Implementations on Foreign Types

impl LosslessTryFrom<u64> for i64

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i128

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI8<UTerm>> for i64

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u64

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i32

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for u128

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u64

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i128

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i32

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for u32

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u8> for i16

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI128<UTerm>> for i128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i8

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i32> for f64

fn lossless_try_from(src: i32) -> Option<f64>

Converts an integer to a floating-point number.

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

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

fn lossless_try_from(src: FixedU32<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<isize> for u8

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i32

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u32

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for usize

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for u16

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i128

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i64

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u32

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u8

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for isize

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<usize> for isize

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i64

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u32> for i16

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for u64

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i16

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<isize> for i128

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u64

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for isize

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for usize

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u16

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u128> for u32

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i16

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for i32

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u128

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i8

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

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

fn lossless_try_from(src: FixedU8<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<i16> for u8

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u64

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for i128

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

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

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

fn lossless_try_from(src: FixedU16<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<FixedU16<UTerm>> for u64

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i32> for u32

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i8

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for f32

fn lossless_try_from(src: u16) -> Option<f32>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<FixedU128<UTerm>> for i64

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for isize

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

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

fn lossless_try_from(src: FixedI8<Frac>) -> Option<f32>

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

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

impl LosslessTryFrom<u128> for isize

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<f64> for f64

fn lossless_try_from(src: f64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i16> for isize

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i32> for i16

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for f32

fn lossless_try_from(src: i8) -> Option<f32>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<i16> for i8

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u16

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u32> for f64

fn lossless_try_from(src: u32) -> Option<f64>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<u128> for u16

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i128

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u8

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u64

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for u32

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u16

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

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

fn lossless_try_from(src: FixedI16<Frac>) -> Option<f32>

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

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

impl LosslessTryFrom<FixedU16<UTerm>> for u16

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u128

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<bool> for u32

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i128> for u8

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for usize

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<f32> for f64

fn lossless_try_from(src: f32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i8> for u128

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u64

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u128> for i128

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u16

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for u128

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i8> for u8

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u64

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<isize> for isize

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU128<UTerm>> for i128

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for i8

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u128

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i32> for u16

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u32

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u128> for i16

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u128

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i16

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i64> for u128

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for usize

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for u32

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i64

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for usize

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u32

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i16

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for f64

fn lossless_try_from(src: i16) -> Option<f64>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<u128> for u8

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for u16

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for isize

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i8> for i32

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u32> for u32

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI16<UTerm>> for u16

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<usize> for i16

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for f64

fn lossless_try_from(src: u16) -> Option<f64>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<isize> for usize

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for isize

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for u128

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i128> for u128

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<bool> for u128

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI16<UTerm>> for i8

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for i128

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for u16

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i32

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i32

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u128> for u128

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<usize> for i8

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i16> for i64

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for u8

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for isize

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u32> for i128

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for u16

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u8> for usize

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i16> for i16

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU128<UTerm>> for isize

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i64> for u64

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for i8

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedI8<Frac>> for f16

fn lossless_try_from(src: FixedI8<Frac>) -> Option<f16>

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

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

impl LosslessTryFrom<FixedI16<UTerm>> for u128

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i64

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i32

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for i64

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

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

fn lossless_try_from(src: FixedI16<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<u16> for usize

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<usize> for u128

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for i32

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for isize

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for isize

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for i32

fn lossless_try_from(src: i16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<isize> for i64

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i16

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<f32> for f32

fn lossless_try_from(src: f32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU16<UTerm>> for u32

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u8

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u32> for isize

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i64

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for usize

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i64

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU16<UTerm>> for i8

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for usize

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u16

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i32> for usize

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for u128

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u16> for u128

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<usize> for i32

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i16

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<f16> for f16

fn lossless_try_from(src: f16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for i128

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI32<UTerm>> for i128

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i32

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for isize

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u64

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for u16

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI8<UTerm>> for u8

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for usize

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u128> for i8

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for isize

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i64

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for i16

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i8> for u64

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for usize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u32

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<isize> for u32

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u64

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for bool

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u32> for i8

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u16

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for i8

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for isize

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

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

fn lossless_try_from(src: FixedI8<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<isize> for u16

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<isize> for i8

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for f16

fn lossless_try_from(src: u8) -> Option<f16>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<FixedU8<UTerm>> for i8

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for i128

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI8<UTerm>> for i32

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for usize

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

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

fn lossless_try_from(src: FixedU8<Frac>) -> Option<f32>

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

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

impl LosslessTryFrom<i64> for i32

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for usize

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i64> for u16

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i16

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl<Frac: LeEqU8> LosslessTryFrom<FixedU8<Frac>> for f16

fn lossless_try_from(src: FixedU8<Frac>) -> Option<f16>

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

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

impl LosslessTryFrom<FixedU8<UTerm>> for i64

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i32> for i128

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i32> for u128

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u64

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<bool> for usize

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU32<UTerm>> for i64

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for i8

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u8

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<isize> for i32

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u64> for i128

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI64<UTerm>> for u8

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i128> for i128

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI128<UTerm>> for u32

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<usize> for u32

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i128

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for i8

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i128> for usize

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<bf16> for f32

fn lossless_try_from(src: bf16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU16<UTerm>> for u8

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u128

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

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

fn lossless_try_from(src: FixedU16<Frac>) -> Option<f32>

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

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

impl LosslessTryFrom<i64> for i16

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i8

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i32

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU32<UTerm>> for u16

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u32> for usize

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for i64

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u16> for u8

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u16

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<isize> for u64

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u64

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i8> for i8

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI32<UTerm>> for u64

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for i8

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for usize

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i32

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for isize

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for u8

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for u8

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for i64

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bf16> for bf16

fn lossless_try_from(src: bf16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for i8

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i32> for isize

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<f16> for f32

fn lossless_try_from(src: f16) -> Option<Self>

Converts a number.

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

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

fn lossless_try_from(src: FixedI32<Frac>) -> Option<f64>

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

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

impl LosslessTryFrom<FixedI128<UTerm>> for i64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u8> for i8

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i8

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for u8

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<isize> for u128

fn lossless_try_from(src: isize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for i64

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u16> for isize

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for u32

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bool> for u64

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i128> for u32

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<usize> for u8

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u128> for u64

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for usize

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i64> for i128

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU64<UTerm>> for u128

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for u128

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for f16

fn lossless_try_from(src: i8) -> Option<f16>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<FixedU8<UTerm>> for u16

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for f64

fn lossless_try_from(src: i8) -> Option<f64>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<u32> for u8

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u64

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u8> for f32

fn lossless_try_from(src: u8) -> Option<f32>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<usize> for u16

fn lossless_try_from(src: usize) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<bool> for i64

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<bf16> for f64

fn lossless_try_from(src: bf16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU64<UTerm>> for usize

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for isize

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU16<UTerm>> for i128

fn lossless_try_from(src: FixedU16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<bool> for i32

fn lossless_try_from(src: bool) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<f16> for f64

fn lossless_try_from(src: f16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u8> for i32

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<u128> for i64

fn lossless_try_from(src: u128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u8

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU128<UTerm>> for u32

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u8> for u64

fn lossless_try_from(src: u8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI16<UTerm>> for i128

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU32<UTerm>> for i16

fn lossless_try_from(src: FixedU32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i64> for usize

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for i64

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU128<UTerm>> for u128

fn lossless_try_from(src: FixedU128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for i32

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedI32<UTerm>> for usize

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u128

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i8> for i128

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<i32> for u8

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i64> for u32

fn lossless_try_from(src: i64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for i16

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI8<UTerm>> for u32

fn lossless_try_from(src: FixedI8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for u8

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u64> for i16

fn lossless_try_from(src: u64) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedU8<UTerm>> for i16

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI32<UTerm>> for i64

fn lossless_try_from(src: FixedI32<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u16> for i16

fn lossless_try_from(src: u16) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u8> for f64

fn lossless_try_from(src: u8) -> Option<f64>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<i8> for isize

fn lossless_try_from(src: i8) -> Option<Self>

Converts a number.

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

impl LosslessTryFrom<FixedU64<UTerm>> for i16

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<u32> for u16

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i32> for u64

fn lossless_try_from(src: i32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<u32> for i32

fn lossless_try_from(src: u32) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<i128> for u16

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI64<UTerm>> for u32

fn lossless_try_from(src: FixedI64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for isize

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for i16

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i16> for f32

fn lossless_try_from(src: i16) -> Option<f32>

Converts an integer to a floating-point number.

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

impl LosslessTryFrom<FixedU8<UTerm>> for i32

fn lossless_try_from(src: FixedU8<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedI16<UTerm>> for u32

fn lossless_try_from(src: FixedI16<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<i128> for i8

fn lossless_try_from(src: i128) -> Option<Self>

Converts a number.

This conversion may fail (fallible) but does not lose any precision (lossless).

impl LosslessTryFrom<FixedI128<UTerm>> for u64

fn lossless_try_from(src: FixedI128<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

impl LosslessTryFrom<FixedU64<UTerm>> for i128

fn lossless_try_from(src: FixedU64<U0>) -> Option<Self>

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose any fractional bits (lossless).

Implementors

impl LosslessTryFrom<i8> for F128

impl LosslessTryFrom<i8> for F128Bits

impl LosslessTryFrom<i16> for F128

impl LosslessTryFrom<i16> for F128Bits

impl LosslessTryFrom<i32> for F128

impl LosslessTryFrom<i32> for F128Bits

impl LosslessTryFrom<i64> for F128

impl LosslessTryFrom<i64> for F128Bits

impl LosslessTryFrom<u8> for F128

impl LosslessTryFrom<u8> for F128Bits

impl LosslessTryFrom<u16> for F128

impl LosslessTryFrom<u16> for F128Bits

impl LosslessTryFrom<u32> for F128

impl LosslessTryFrom<u32> for F128Bits

impl LosslessTryFrom<u64> for F128

impl LosslessTryFrom<u64> for F128Bits

impl<Frac: LeEqU8> LosslessTryFrom<bool> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<bool> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i8> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i8> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i16> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i16> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i32> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i32> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i64> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i64> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i128> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<i128> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<isize> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<isize> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u8> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u8> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u16> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u16> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u32> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u32> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u64> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u64> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u128> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<u128> for FixedU8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<usize> for FixedI8<Frac>

impl<Frac: LeEqU8> LosslessTryFrom<usize> for FixedU8<Frac>

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

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

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

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

impl<Frac: LeEqU16> LosslessTryFrom<bool> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<bool> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i8> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i8> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i16> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i16> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i32> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i32> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i64> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i64> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i128> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<i128> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<isize> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<isize> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u8> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u8> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u16> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u16> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u32> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u32> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u64> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u64> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u128> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<u128> for FixedU16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<usize> for FixedI16<Frac>

impl<Frac: LeEqU16> LosslessTryFrom<usize> for FixedU16<Frac>

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

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

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

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

impl<Frac: LeEqU32> LosslessTryFrom<bool> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<bool> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i8> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i8> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i16> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i16> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i32> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i32> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i64> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i64> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i128> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<i128> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<isize> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<isize> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u8> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u8> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u16> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u16> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u32> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u32> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u64> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u64> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u128> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<u128> for FixedU32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<usize> for FixedI32<Frac>

impl<Frac: LeEqU32> LosslessTryFrom<usize> for FixedU32<Frac>

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

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

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

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

impl<Frac: LeEqU32> LosslessTryFrom<f16> for FixedI32<Frac>where U24: IsLessOrEqual<Frac, Output = True>,

impl<Frac: LeEqU64> LosslessTryFrom<bool> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<bool> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i8> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i8> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i16> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i16> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i32> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i32> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i64> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i64> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i128> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<i128> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<isize> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<isize> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u8> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u8> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u16> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u16> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u32> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u32> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u64> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u64> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u128> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<u128> for FixedU64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<usize> for FixedI64<Frac>

impl<Frac: LeEqU64> LosslessTryFrom<usize> for FixedU64<Frac>

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

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

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

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

impl<Frac: LeEqU64> LosslessTryFrom<f16> for FixedI64<Frac>where U24: IsLessOrEqual<Frac, Output = True>,

impl<Frac: LeEqU128> LosslessTryFrom<bool> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<bool> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i8> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i8> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i16> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i16> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i32> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i32> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i64> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i64> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i128> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<i128> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<isize> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<isize> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u8> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u8> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u16> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u16> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u32> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u32> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u64> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u64> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u128> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<u128> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<usize> for FixedI128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<usize> for FixedU128<Frac>

impl<Frac: LeEqU128> LosslessTryFrom<f16> for FixedI128<Frac>where U24: IsLessOrEqual<Frac, Output = True>,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI8<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI8<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI16<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI16<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI32<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI32<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI64<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedI128<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU8<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU8<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU16<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU16<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU32<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU64<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU64<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU128<FracSrc>> for FixedI8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU8> LosslessTryFrom<FixedU128<FracSrc>> for FixedU8<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI8<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI8<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI16<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI16<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI32<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI32<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI64<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedI128<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU8<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU8<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU16<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU16<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU32<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU64<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU64<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU128<FracSrc>> for FixedI16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU16> LosslessTryFrom<FixedU128<FracSrc>> for FixedU16<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI8<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI16<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI32<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI64<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedI128<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU8<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU16<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU32<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU64<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedI32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU32> LosslessTryFrom<FixedU128<FracSrc>> for FixedU32<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI8<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI8<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI16<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI16<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI32<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI32<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI64<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedI128<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU8<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU8<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU16<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU16<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU32<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU64<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU64<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU128<FracSrc>> for FixedI64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU64> LosslessTryFrom<FixedU128<FracSrc>> for FixedU64<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI8<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI8<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI16<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI16<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI32<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI32<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI64<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedI128<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU8<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU8<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU8,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU16<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU16<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU16,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU32<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU32,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU64<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU64<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU64,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU128<FracSrc>> for FixedI128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,

impl<FracSrc, FracDst: LeEqU128> LosslessTryFrom<FixedU128<FracSrc>> for FixedU128<FracDst>where FracSrc: IsLessOrEqual<FracDst, Output = True> + LeEqU128,