Trait fixed::traits::LossyFrom

[+] Show declaration

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

[−] Expand description

This trait provides infallible conversions that might be lossy.

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

Examples

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

Required methods

fn lossy_from(src: Src) -> Self[−]

Performs the conversion.

Implementors

impl LossyFrom<bool> for bool[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for i8[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for i16[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for i32[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for i64[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for i128[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for isize[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for u8[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for u16[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for u32[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for u64[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for u128[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<bool> for usize[+]

fn lossy_from(src: bool) -> Self[−]

Converts a number.

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

impl LossyFrom<f32> for f32[+]

fn lossy_from(src: f32) -> Self[−]

Converts a number.

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

impl LossyFrom<f32> for f64[+]

fn lossy_from(src: f32) -> Self[−]

Converts a number.

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

impl LossyFrom<f64> for f32[+]

fn lossy_from(src: f64) -> f32[−]

Converts a number.

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

impl LossyFrom<f64> for f64[+]

fn lossy_from(src: f64) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for FixedI8<U0>[+]

fn lossy_from(src: i8) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<i8> for f32[+]

fn lossy_from(src: i8) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i8> for f64[+]

fn lossy_from(src: i8) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i8> for i8[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for i16[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for i32[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for i64[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for i128[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i8> for isize[+]

fn lossy_from(src: i8) -> Self[−]

Converts a number.

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

impl LossyFrom<i16> for FixedI16<U0>[+]

fn lossy_from(src: i16) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<i16> for f32[+]

fn lossy_from(src: i16) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i16> for f64[+]

fn lossy_from(src: i16) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i16> for i16[+]

fn lossy_from(src: i16) -> Self[−]

Converts a number.

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

impl LossyFrom<i16> for i32[+]

fn lossy_from(src: i16) -> Self[−]

Converts a number.

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

impl LossyFrom<i16> for i64[+]

fn lossy_from(src: i16) -> Self[−]

Converts a number.

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

impl LossyFrom<i16> for i128[+]

fn lossy_from(src: i16) -> Self[−]

Converts a number.

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

impl LossyFrom<i16> for isize[+]

fn lossy_from(src: i16) -> Self[−]

Converts a number.

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

impl LossyFrom<i32> for FixedI32<U0>[+]

fn lossy_from(src: i32) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<i32> for f32[+]

fn lossy_from(src: i32) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i32> for f64[+]

fn lossy_from(src: i32) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i32> for i32[+]

fn lossy_from(src: i32) -> Self[−]

Converts a number.

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

impl LossyFrom<i32> for i64[+]

fn lossy_from(src: i32) -> Self[−]

Converts a number.

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

impl LossyFrom<i32> for i128[+]

fn lossy_from(src: i32) -> Self[−]

Converts a number.

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

impl LossyFrom<i64> for FixedI64<U0>[+]

fn lossy_from(src: i64) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<i64> for f32[+]

fn lossy_from(src: i64) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i64> for f64[+]

fn lossy_from(src: i64) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i64> for i64[+]

fn lossy_from(src: i64) -> Self[−]

Converts a number.

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

impl LossyFrom<i64> for i128[+]

fn lossy_from(src: i64) -> Self[−]

Converts a number.

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

impl LossyFrom<i128> for FixedI128<U0>[+]

fn lossy_from(src: i128) -> Self[−]

Converts an integer to a fixed-point 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 LossyFrom<i128> for f64[+]

fn lossy_from(src: i128) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<i128> for i128[+]

fn lossy_from(src: i128) -> Self[−]

Converts a number.

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

impl LossyFrom<isize> for f32[+]

fn lossy_from(src: isize) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<isize> for f64[+]

fn lossy_from(src: isize) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<isize> for isize[+]

fn lossy_from(src: isize) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for FixedU8<U0>[+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<u8> for f32[+]

fn lossy_from(src: u8) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u8> for f64[+]

fn lossy_from(src: u8) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u8> for i16[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for i32[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for i64[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for i128[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for isize[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for u8[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for u16[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for u32[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for u64[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for u128[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u8> for usize[+]

fn lossy_from(src: u8) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for FixedU16<U0>[+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<u16> for f32[+]

fn lossy_from(src: u16) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u16> for f64[+]

fn lossy_from(src: u16) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u16> for i32[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for i64[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for i128[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for u16[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for u32[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for u64[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for u128[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u16> for usize[+]

fn lossy_from(src: u16) -> Self[−]

Converts a number.

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

impl LossyFrom<u32> for FixedU32<U0>[+]

fn lossy_from(src: u32) -> Self[−]

Converts an integer to a fixed-point 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<u32> for f64[+]

fn lossy_from(src: u32) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u32> for i64[+]

fn lossy_from(src: u32) -> Self[−]

Converts a number.

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

impl LossyFrom<u32> for i128[+]

fn lossy_from(src: u32) -> Self[−]

Converts a number.

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

impl LossyFrom<u32> for u32[+]

fn lossy_from(src: u32) -> Self[−]

Converts a number.

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

impl LossyFrom<u32> for u64[+]

fn lossy_from(src: u32) -> Self[−]

Converts a number.

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

impl LossyFrom<u32> for u128[+]

fn lossy_from(src: u32) -> Self[−]

Converts a number.

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

impl LossyFrom<u64> for FixedU64<U0>[+]

fn lossy_from(src: u64) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<u64> for f32[+]

fn lossy_from(src: u64) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u64> for f64[+]

fn lossy_from(src: u64) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u64> for i128[+]

fn lossy_from(src: u64) -> Self[−]

Converts a number.

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

impl LossyFrom<u64> for u64[+]

fn lossy_from(src: u64) -> Self[−]

Converts a number.

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

impl LossyFrom<u64> for u128[+]

fn lossy_from(src: u64) -> Self[−]

Converts a number.

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

impl LossyFrom<u128> for FixedU128<U0>[+]

fn lossy_from(src: u128) -> Self[−]

Converts an integer to a fixed-point number.

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

impl LossyFrom<u128> for f32[+]

fn lossy_from(src: u128) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u128> for f64[+]

fn lossy_from(src: u128) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<u128> for u128[+]

fn lossy_from(src: u128) -> Self[−]

Converts a number.

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

impl LossyFrom<usize> for f32[+]

fn lossy_from(src: usize) -> f32[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<usize> for f64[+]

fn lossy_from(src: usize) -> f64[−]

Converts an integer to a floating-point number.

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

impl LossyFrom<usize> for usize[+]

fn lossy_from(src: usize) -> Self[−]

Converts a number.

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

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU8> LossyFrom<FixedI8<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU8> LossyFrom<FixedU8<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU16> LossyFrom<FixedI16<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU16> LossyFrom<FixedU16<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU32> LossyFrom<FixedI32<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU32> LossyFrom<FixedU32<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU64> LossyFrom<FixedI64<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU64> LossyFrom<FixedU64<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU128> LossyFrom<FixedI128<Frac>> for f64[+]

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

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

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

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for f32[+]

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

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

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

impl<Frac: LeEqU128> LossyFrom<FixedU128<Frac>> for f64[+]

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

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

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

impl<FracDst: LeEqU8> LossyFrom<bool> for FixedI8<FracDst> where
    U7: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU8> LossyFrom<bool> for FixedU8<FracDst> where
    U8: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU16> LossyFrom<bool> for FixedI16<FracDst> where
    U15: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU16> LossyFrom<bool> for FixedU16<FracDst> where
    U16: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU16> LossyFrom<i8> for FixedI16<FracDst> where
    U16: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

fn lossy_from(src: i8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU16> LossyFrom<u8> for FixedI16<FracDst> where
    U15: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU16> LossyFrom<u8> for FixedU16<FracDst> where
    U16: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<bool> for FixedI32<FracDst> where
    U31: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<bool> for FixedU32<FracDst> where
    U32: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<i8> for FixedI32<FracDst> where
    U32: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

fn lossy_from(src: i8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<i16> for FixedI32<FracDst> where
    U32: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

fn lossy_from(src: i16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<u8> for FixedI32<FracDst> where
    U31: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<u8> for FixedU32<FracDst> where
    U32: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<u16> for FixedI32<FracDst> where
    U31: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU32> LossyFrom<u16> for FixedU32<FracDst> where
    U32: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<bool> for FixedI64<FracDst> where
    U63: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<bool> for FixedU64<FracDst> where
    U64: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<i8> for FixedI64<FracDst> where
    U64: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: i8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<i16> for FixedI64<FracDst> where
    U64: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: i16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<i32> for FixedI64<FracDst> where
    U64: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: i32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u8> for FixedI64<FracDst> where
    U63: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u8> for FixedU64<FracDst> where
    U64: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u16> for FixedI64<FracDst> where
    U63: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u16> for FixedU64<FracDst> where
    U64: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u32> for FixedI64<FracDst> where
    U63: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

fn lossy_from(src: u32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU64> LossyFrom<u32> for FixedU64<FracDst> where
    U64: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

fn lossy_from(src: u32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<bool> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<bool> for FixedU128<FracDst> where
    U128: Sub<FracDst>,
    U1: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: bool) -> Self[−]

Converts a bool to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i8> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: i8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i16> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: i16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i32> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: i32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<i64> for FixedI128<FracDst> where
    U128: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: i64) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u8> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u8> for FixedU128<FracDst> where
    U128: Sub<FracDst>,
    U8: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: u8) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u16> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u16> for FixedU128<FracDst> where
    U128: Sub<FracDst>,
    U16: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: u16) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u32> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

fn lossy_from(src: u32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u32> for FixedU128<FracDst> where
    U128: Sub<FracDst>,
    U32: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: u32) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u64> for FixedI128<FracDst> where
    U127: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

fn lossy_from(src: u64) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracDst: LeEqU128> LossyFrom<u64> for FixedU128<FracDst> where
    U128: Sub<FracDst>,
    U64: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

fn lossy_from(src: u64) -> Self[−]

Converts an integer to a fixed-point number.

This conversion never fails (infallible) and cannot lose any fractional bits, so it is actually lossless.

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i8 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i16 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i32 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i64 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for i128 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedI8<FracSrc>> for isize where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i8 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U7, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i16 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i32 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U31, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i64 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U63, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for i128 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U127, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for isize where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u8 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u16 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u32 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u64 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for u128 where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8> LossyFrom<FixedU8<FracSrc>> for usize where
    U8: Sub<FracSrc>,
    Diff<U8, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedI8<FracSrc>> for FixedI8<FracDst> where
    U8: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedU8<FracSrc>> for FixedI8<FracDst> where
    U8: Sub<FracSrc>,
    U7: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU8> LossyFrom<FixedU8<FracSrc>> for FixedU8<FracDst> where
    U8: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedI8<FracSrc>> for FixedI16<FracDst> where
    U8: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedU8<FracSrc>> for FixedI16<FracDst> where
    U8: Sub<FracSrc>,
    U15: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU16> LossyFrom<FixedU8<FracSrc>> for FixedU16<FracDst> where
    U8: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedI8<FracSrc>> for FixedI32<FracDst> where
    U8: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedU8<FracSrc>> for FixedI32<FracDst> where
    U8: Sub<FracSrc>,
    U31: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU32> LossyFrom<FixedU8<FracSrc>> for FixedU32<FracDst> where
    U8: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedI8<FracSrc>> for FixedI64<FracDst> where
    U8: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedU8<FracSrc>> for FixedI64<FracDst> where
    U8: Sub<FracSrc>,
    U63: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU64> LossyFrom<FixedU8<FracSrc>> for FixedU64<FracDst> where
    U8: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedI8<FracSrc>> for FixedI128<FracDst> where
    U8: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedU8<FracSrc>> for FixedI128<FracDst> where
    U8: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU8, FracDst: LeEqU128> LossyFrom<FixedU8<FracSrc>> for FixedU128<FracDst> where
    U8: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U8, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i8 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i16 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i32 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i64 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for i128 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedI16<FracSrc>> for isize where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i8 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U7, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i16 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i32 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U31, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i64 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U63, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for i128 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U127, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for isize where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u8 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u16 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u32 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u64 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for u128 where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16> LossyFrom<FixedU16<FracSrc>> for usize where
    U16: Sub<FracSrc>,
    Diff<U16, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedI16<FracSrc>> for FixedI8<FracDst> where
    U16: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedU16<FracSrc>> for FixedI8<FracDst> where
    U16: Sub<FracSrc>,
    U7: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU8> LossyFrom<FixedU16<FracSrc>> for FixedU8<FracDst> where
    U16: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedI16<FracSrc>> for FixedI16<FracDst> where
    U16: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedU16<FracSrc>> for FixedI16<FracDst> where
    U16: Sub<FracSrc>,
    U15: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU16> LossyFrom<FixedU16<FracSrc>> for FixedU16<FracDst> where
    U16: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedI16<FracSrc>> for FixedI32<FracDst> where
    U16: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedU16<FracSrc>> for FixedI32<FracDst> where
    U16: Sub<FracSrc>,
    U31: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU32> LossyFrom<FixedU16<FracSrc>> for FixedU32<FracDst> where
    U16: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedI16<FracSrc>> for FixedI64<FracDst> where
    U16: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedU16<FracSrc>> for FixedI64<FracDst> where
    U16: Sub<FracSrc>,
    U63: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU64> LossyFrom<FixedU16<FracSrc>> for FixedU64<FracDst> where
    U16: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedI16<FracSrc>> for FixedI128<FracDst> where
    U16: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedU16<FracSrc>> for FixedI128<FracDst> where
    U16: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU16, FracDst: LeEqU128> LossyFrom<FixedU16<FracSrc>> for FixedU128<FracDst> where
    U16: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U16, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i8 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i16 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i32 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i64 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for i128 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedI32<FracSrc>> for isize where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i8 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U7, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i16 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i32 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U31, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i64 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U63, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for i128 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U127, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for isize where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u8 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u16 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u32 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u64 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for u128 where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32> LossyFrom<FixedU32<FracSrc>> for usize where
    U32: Sub<FracSrc>,
    Diff<U32, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedI32<FracSrc>> for FixedI8<FracDst> where
    U32: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedU32<FracSrc>> for FixedI8<FracDst> where
    U32: Sub<FracSrc>,
    U7: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU8> LossyFrom<FixedU32<FracSrc>> for FixedU8<FracDst> where
    U32: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedI32<FracSrc>> for FixedI16<FracDst> where
    U32: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedU32<FracSrc>> for FixedI16<FracDst> where
    U32: Sub<FracSrc>,
    U15: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU16> LossyFrom<FixedU32<FracSrc>> for FixedU16<FracDst> where
    U32: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedI32<FracSrc>> for FixedI32<FracDst> where
    U32: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedU32<FracSrc>> for FixedI32<FracDst> where
    U32: Sub<FracSrc>,
    U31: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU32> LossyFrom<FixedU32<FracSrc>> for FixedU32<FracDst> where
    U32: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedI32<FracSrc>> for FixedI64<FracDst> where
    U32: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedU32<FracSrc>> for FixedI64<FracDst> where
    U32: Sub<FracSrc>,
    U63: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU64> LossyFrom<FixedU32<FracSrc>> for FixedU64<FracDst> where
    U32: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedI32<FracSrc>> for FixedI128<FracDst> where
    U32: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedU32<FracSrc>> for FixedI128<FracDst> where
    U32: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU32, FracDst: LeEqU128> LossyFrom<FixedU32<FracSrc>> for FixedU128<FracDst> where
    U32: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U32, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i8 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i16 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i32 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i64 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for i128 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedI64<FracSrc>> for isize where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i8 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U7, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i16 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i32 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U31, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i64 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U63, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for i128 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U127, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for isize where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u8 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u16 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u32 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u64 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for u128 where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64> LossyFrom<FixedU64<FracSrc>> for usize where
    U64: Sub<FracSrc>,
    Diff<U64, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedI64<FracSrc>> for FixedI8<FracDst> where
    U64: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedU64<FracSrc>> for FixedI8<FracDst> where
    U64: Sub<FracSrc>,
    U7: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU8> LossyFrom<FixedU64<FracSrc>> for FixedU8<FracDst> where
    U64: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedI64<FracSrc>> for FixedI16<FracDst> where
    U64: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedU64<FracSrc>> for FixedI16<FracDst> where
    U64: Sub<FracSrc>,
    U15: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU16> LossyFrom<FixedU64<FracSrc>> for FixedU16<FracDst> where
    U64: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedI64<FracSrc>> for FixedI32<FracDst> where
    U64: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedU64<FracSrc>> for FixedI32<FracDst> where
    U64: Sub<FracSrc>,
    U31: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU32> LossyFrom<FixedU64<FracSrc>> for FixedU32<FracDst> where
    U64: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedI64<FracSrc>> for FixedI64<FracDst> where
    U64: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedU64<FracSrc>> for FixedI64<FracDst> where
    U64: Sub<FracSrc>,
    U63: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU64> LossyFrom<FixedU64<FracSrc>> for FixedU64<FracDst> where
    U64: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedI64<FracSrc>> for FixedI128<FracDst> where
    U64: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedU64<FracSrc>> for FixedI128<FracDst> where
    U64: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU64, FracDst: LeEqU128> LossyFrom<FixedU64<FracSrc>> for FixedU128<FracDst> where
    U64: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U64, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i8 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i16 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i32 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i64 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for i128 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedI128<FracSrc>> for isize where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i8 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U7, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i16 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i32 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U31, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i64 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U63, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for i128 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U127, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for isize where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U15, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u8 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U8, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u16 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u32 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U32, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u64 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U64, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for u128 where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U128, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128> LossyFrom<FixedU128<FracSrc>> for usize where
    U128: Sub<FracSrc>,
    Diff<U128, FracSrc>: IsLessOrEqual<U16, Output = True>, [+]

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

Converts a fixed-point number to an integer.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedI128<FracSrc>> for FixedI8<FracDst> where
    U128: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedU128<FracSrc>> for FixedI8<FracDst> where
    U128: Sub<FracSrc>,
    U7: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U7, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU8> LossyFrom<FixedU128<FracSrc>> for FixedU8<FracDst> where
    U128: Sub<FracSrc>,
    U8: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U8, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedI128<FracSrc>> for FixedI16<FracDst> where
    U128: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedU128<FracSrc>> for FixedI16<FracDst> where
    U128: Sub<FracSrc>,
    U15: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U15, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU16> LossyFrom<FixedU128<FracSrc>> for FixedU16<FracDst> where
    U128: Sub<FracSrc>,
    U16: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U16, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedI128<FracSrc>> for FixedI32<FracDst> where
    U128: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedU128<FracSrc>> for FixedI32<FracDst> where
    U128: Sub<FracSrc>,
    U31: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U31, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU32> LossyFrom<FixedU128<FracSrc>> for FixedU32<FracDst> where
    U128: Sub<FracSrc>,
    U32: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U32, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedI128<FracSrc>> for FixedI64<FracDst> where
    U128: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedU128<FracSrc>> for FixedI64<FracDst> where
    U128: Sub<FracSrc>,
    U63: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U63, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU64> LossyFrom<FixedU128<FracSrc>> for FixedU64<FracDst> where
    U128: Sub<FracSrc>,
    U64: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U64, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedI128<FracSrc>> for FixedI128<FracDst> where
    U128: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedU128<FracSrc>> for FixedI128<FracDst> where
    U128: Sub<FracSrc>,
    U127: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U127, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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

impl<FracSrc: LeEqU128, FracDst: LeEqU128> LossyFrom<FixedU128<FracSrc>> for FixedU128<FracDst> where
    U128: Sub<FracSrc>,
    U128: Sub<FracDst>,
    Diff<U128, FracSrc>: IsLessOrEqual<Diff<U128, FracDst>, Output = True>, [+]

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

Converts a fixed-pint number.

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