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

#![feature(generic_const_exprs)]

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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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 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 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<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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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 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<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<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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for f32

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<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<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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for f32

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for f16

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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 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<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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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 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<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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot 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<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<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for f32

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

impl<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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 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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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<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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

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<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<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<const FRAC: i32> LosslessTryFrom<FixedU128<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for f16

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<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<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for f32

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<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<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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot 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<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<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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<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<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<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<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (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<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for f64

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

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

This conversion may fail (fallible) but cannot lose precision (lossless). As a consequency, ∞ are −∞ are never returned, as they would lose precision.

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<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose 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<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<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI128<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion may fail (fallible) but cannot lose precision (lossless).

Implementors

impl LosslessTryFrom<i8> for F128

impl LosslessTryFrom<i16> for F128

impl LosslessTryFrom<i32> for F128

impl LosslessTryFrom<i64> for F128

impl LosslessTryFrom<u8> for F128

impl LosslessTryFrom<u16> for F128

impl LosslessTryFrom<u32> for F128

impl LosslessTryFrom<u64> for F128

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<bool> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i8> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i16> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i32> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i64> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<i128> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<isize> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u8> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u16> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u32> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u64> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<u128> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedI8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedI16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedU8<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedU16<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedU32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedU64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<usize> for FixedU128<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<FixedI8<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedI16<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedI32<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedI64<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedU8<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedU16<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedU32<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<FixedU64<FRAC>> for F128

impl<const FRAC: i32> LosslessTryFrom<f16> for FixedI32<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<f16> for FixedI64<FRAC>where If<{ _ }>: True,

impl<const FRAC: i32> LosslessTryFrom<f16> for FixedI128<FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI8<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI16<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI32<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI64<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedI128<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU8<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU16<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU32<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU64<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedI8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedI16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedI32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedI64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedI128<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedU8<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedU16<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedU32<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedU64<DST_FRAC>where If<{ _ }>: True,

impl<const SRC_FRAC: i32, const DST_FRAC: i32> LosslessTryFrom<FixedU128<SRC_FRAC>> for FixedU128<DST_FRAC>where If<{ _ }>: True,