Trait fixed::traits::LossyFrom

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

This trait provides infallible conversions that might be lossy.

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

Examples

#![feature(generic_const_exprs)]

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

Required Methods

fn lossy_from(src: Src) -> Self

Performs the conversion.

Implementations on Foreign Types

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for bf16

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

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

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

impl LossyFrom<bool> for i8

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<u32> for u64

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for f16

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

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

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

impl LossyFrom<f16> for bf16

fn lossy_from(src: f16) -> bf16

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for f64

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u16> for f32

fn lossy_from(src: u16) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for f64

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

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

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u64> for bf16

fn lossy_from(src: u64) -> bf16

Converts an integer to a floating-point number.

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

impl LossyFrom<u32> for f16

fn lossy_from(src: u32) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<u8> for i128

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<i128> for f32

fn lossy_from(src: i128) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for isize

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u128> for u128

fn lossy_from(src: u128) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i64> for f64

fn lossy_from(src: i64) -> f64

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bool> for bool

fn lossy_from(src: bool) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for u64

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for u32

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u8> for i64

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<bool> for isize

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<isize> for f16

fn lossy_from(src: isize) -> f16

Converts an integer to a floating-point number.

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

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

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for u16

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for bf16

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i64> for f32

fn lossy_from(src: i64) -> f32

Converts an integer to a floating-point number.

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

impl LossyFrom<u64> for u128

fn lossy_from(src: u64) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i8> for isize

fn lossy_from(src: i8) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for usize

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<f64> for f64

fn lossy_from(src: f64) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for bf16

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

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

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

impl LossyFrom<i64> for bf16

fn lossy_from(src: i64) -> bf16

Converts an integer to a floating-point number.

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

impl LossyFrom<i8> for f64

fn lossy_from(src: i8) -> f64

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for bf16

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for f16

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for f32

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i8> for bf16

fn lossy_from(src: i8) -> bf16

Converts an integer to a floating-point number.

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

impl LossyFrom<f64> for bf16

fn lossy_from(src: f64) -> bf16

Converts a number.

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

impl LossyFrom<bool> for u8

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<u64> for f16

fn lossy_from(src: u64) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<f64> for f32

fn lossy_from(src: f64) -> f32

Converts a number.

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

impl LossyFrom<i32> for i32

fn lossy_from(src: i32) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i128> for i128

fn lossy_from(src: i128) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for f16

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

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

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

impl LossyFrom<u16> for f64

fn lossy_from(src: u16) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<u16> for i32

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for f16

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

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

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for f16

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bool> for i32

fn lossy_from(src: bool) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI8<FRAC>> for bf16

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

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

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

impl LossyFrom<f32> for f64

fn lossy_from(src: f32) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u128> for f32

fn lossy_from(src: u128) -> f32

Converts an integer to a floating-point number.

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

impl LossyFrom<i16> for f32

fn lossy_from(src: i16) -> f32

Converts an integer to a floating-point number.

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

impl LossyFrom<isize> for f32

fn lossy_from(src: isize) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i64> for i64

fn lossy_from(src: i64) -> Self

Converts a number.

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

impl LossyFrom<bool> for u64

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<usize> for bf16

fn lossy_from(src: usize) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI8<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<f32> for f32

fn lossy_from(src: f32) -> Self

Converts a number.

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

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

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

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

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

impl LossyFrom<bool> for i16

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<i8> for i8

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i16> for f16

fn lossy_from(src: i16) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<i128> for f16

fn lossy_from(src: i128) -> f16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for f16

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bf16> for f32

fn lossy_from(src: bf16) -> Self

Converts a number.

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

impl LossyFrom<isize> for f64

fn lossy_from(src: isize) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<f32> for f16

fn lossy_from(src: f32) -> f16

Converts a number.

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

impl LossyFrom<u32> for i128

fn lossy_from(src: u32) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for f64

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

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

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

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bool> for u128

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<i8> for i16

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<u16> for f16

fn lossy_from(src: u16) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<u32> for u128

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl LossyFrom<u8> for u8

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for f64

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

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

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

impl LossyFrom<i32> for f32

fn lossy_from(src: i32) -> f32

Converts an integer to a floating-point number.

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

impl LossyFrom<isize> for isize

fn lossy_from(src: isize) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for f32

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u64> for u64

fn lossy_from(src: u64) -> Self

Converts a number.

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

impl LossyFrom<u32> for f32

fn lossy_from(src: u32) -> f32

Converts an integer to a floating-point number.

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

impl LossyFrom<u64> for i128

fn lossy_from(src: u64) -> Self

Converts a number.

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

impl LossyFrom<usize> for usize

fn lossy_from(src: usize) -> Self

Converts a number.

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

impl LossyFrom<i16> for i16

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for f32

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i128> for bf16

fn lossy_from(src: i128) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for bf16

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

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

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

impl LossyFrom<i16> for i128

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<u64> for f64

fn lossy_from(src: u64) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<u16> for u32

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<u8> for i16

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for f32

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

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

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

impl LossyFrom<usize> for f64

fn lossy_from(src: usize) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<u32> for u32

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for u128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bf16> for bf16

fn lossy_from(src: bf16) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u32> for bf16

fn lossy_from(src: u32) -> bf16

Converts an integer to a floating-point number.

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

impl LossyFrom<i32> for i64

fn lossy_from(src: i32) -> Self

Converts a number.

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

impl LossyFrom<u128> for f16

fn lossy_from(src: u128) -> f16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for u16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i64> for f16

fn lossy_from(src: i64) -> f16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for f64

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

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

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

impl LossyFrom<i8> for f16

fn lossy_from(src: i8) -> f16

Converts an integer to a floating-point number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i128> for f64

fn lossy_from(src: i128) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<u64> for f32

fn lossy_from(src: u64) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for u32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u128> for f64

fn lossy_from(src: u128) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<u8> for u128

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<u16> for i64

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<i16> for i64

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl LossyFrom<bf16> for f16

fn lossy_from(src: bf16) -> f16

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u32> for i64

fn lossy_from(src: u32) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for i16where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i8> for f32

fn lossy_from(src: i8) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI8<FRAC>> for f32

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

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

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

impl LossyFrom<u8> for f32

fn lossy_from(src: u8) -> f32

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for i64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u8> for i32

fn lossy_from(src: u8) -> Self

Converts a number.

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

impl LossyFrom<i32> for f16

fn lossy_from(src: i32) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<u128> for bf16

fn lossy_from(src: u128) -> bf16

Converts an integer to a floating-point number.

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

impl LossyFrom<u8> for f16

fn lossy_from(src: u8) -> f16

Converts an integer to a floating-point number.

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

impl LossyFrom<u16> for bf16

fn lossy_from(src: u16) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for f64

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

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

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

impl LossyFrom<i8> for i32

fn lossy_from(src: i8) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU8<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u16> for i128

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<bool> for usize

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bool> for i64

fn lossy_from(src: bool) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for bf16

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

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

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

impl LossyFrom<u16> for u64

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<bool> for i128

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<bf16> for f64

fn lossy_from(src: bf16) -> Self

Converts a number.

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

impl LossyFrom<usize> for f32

fn lossy_from(src: usize) -> f32

Converts an integer to a floating-point number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for isizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u16> for u128

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<i16> for f64

fn lossy_from(src: i16) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<f64> for f16

fn lossy_from(src: f64) -> f16

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for u8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI64<FRAC>> for f16

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

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

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

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

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

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

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

impl LossyFrom<f16> for f64

fn lossy_from(src: f16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for usizewhere If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u32> for f64

fn lossy_from(src: u32) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<bool> for u32

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for i32where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<u16> for u16

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for f16

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

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

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

impl LossyFrom<i16> for isize

fn lossy_from(src: i16) -> Self

Converts a number.

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for bf16

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i16> for bf16

fn lossy_from(src: i16) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for i128where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i8> for i64

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl LossyFrom<f16> for f16

fn lossy_from(src: f16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU16<FRAC>> for bf16

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for u64where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<i32> for i128

fn lossy_from(src: i32) -> Self

Converts a number.

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

impl LossyFrom<bool> for u16

fn lossy_from(src: bool) -> Self

Converts a number.

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

impl LossyFrom<isize> for bf16

fn lossy_from(src: isize) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for f32

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

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

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

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

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

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

impl LossyFrom<f32> for bf16

fn lossy_from(src: f32) -> bf16

Converts a number.

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

impl LossyFrom<u8> for f64

fn lossy_from(src: u8) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<i8> for i128

fn lossy_from(src: i8) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for f32

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

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

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

impl LossyFrom<i32> for f64

fn lossy_from(src: i32) -> f64

Converts an integer to a floating-point number.

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

impl LossyFrom<i64> for i128

fn lossy_from(src: i64) -> Self

Converts a number.

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

impl LossyFrom<u16> for usize

fn lossy_from(src: u16) -> Self

Converts a number.

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

impl LossyFrom<i32> for bf16

fn lossy_from(src: i32) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for f32

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

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

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

impl LossyFrom<u8> for bf16

fn lossy_from(src: u8) -> bf16

Converts an integer to a floating-point number.

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

impl<const FRAC: i32> LossyFrom<FixedI32<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for bf16

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

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

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

impl LossyFrom<i16> for i32

fn lossy_from(src: i16) -> Self

Converts a number.

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

impl<const FRAC: i32> LossyFrom<FixedU64<FRAC>> for f64

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU32<FRAC>> for f64

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

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

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

impl<const FRAC: i32> LossyFrom<FixedI16<FRAC>> for i8where If<{ _ }>: True,

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

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

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

Converts a fixed-point number to an integer.

This conversion never fails (infallible) but may lose precision (lossy). Any low-significance bits in the source that cannot be represented in the destination are discarded, which rounds towards −∞.

impl LossyFrom<f16> for f32

fn lossy_from(src: f16) -> Self

Converts a number.

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

impl LossyFrom<usize> for f16

fn lossy_from(src: usize) -> f16

Converts an integer to a floating-point number.

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

Implementors

impl LossyFrom<i8> for F128

impl LossyFrom<i16> for F128

impl LossyFrom<i32> for F128

impl LossyFrom<i64> for F128

impl LossyFrom<i128> for F128

impl LossyFrom<isize> for F128

impl LossyFrom<u8> for F128

impl LossyFrom<u16> for F128

impl LossyFrom<u32> for F128

impl LossyFrom<u64> for F128

impl LossyFrom<u128> for F128

impl LossyFrom<usize> for F128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<const FRAC: i32> LossyFrom<FixedI128<FRAC>> for F128

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

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

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

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

impl<const FRAC: i32> LossyFrom<FixedU128<FRAC>> for F128

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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