Struct F4E2M1x2 

pub struct F4E2M1x2(/* private fields */);

Two F4E2M1 values packed into a single byte.

The lower nibble (bits 3:0) holds the first value and the upper nibble (bits 7:4) holds the second value. This layout matches NVIDIA’s __nv_fp4x2_e2m1 format.

Examples

use float4::{F4E2M1, F4E2M1x2};

let lo = F4E2M1::from_f64(1.5);
let hi = F4E2M1::from_f64(-2.0);
let packed = F4E2M1x2::new(lo, hi);

assert_eq!(packed.lo().to_f64(), 1.5);
assert_eq!(packed.hi().to_f64(), -2.0);

Implementations

impl F4E2M1x2

pub const ZERO: Self

Two positive zeros.

pub const fn new(lo: F4E2M1, hi: F4E2M1) -> Self

Packs two F4E2M1 values into a single byte.

lo occupies bits 3:0 and hi occupies bits 7:4.

pub const fn from_bits(bits: u8) -> Self

Wraps a raw byte directly.

pub const fn to_bits(self) -> u8

Returns the raw byte.

pub const fn lo(self) -> F4E2M1

Extracts the lower nibble as an F4E2M1.

pub const fn hi(self) -> F4E2M1

Extracts the upper nibble as an F4E2M1.

pub fn from_f32_pair(a: f32, b: f32) -> Self

Creates a packed pair by converting two f32 values to F4E2M1.

Each value is independently rounded to the nearest representable F4E2M1 value using round-to-nearest-even.

Examples

use float4::F4E2M1x2;

let packed = F4E2M1x2::from_f32_pair(1.5, -2.0);
assert_eq!(packed.lo().to_f64(), 1.5);
assert_eq!(packed.hi().to_f64(), -2.0);

pub fn to_f32_pair(self) -> (f32, f32)

Extracts both values as an (f32, f32) pair.

Examples

use float4::F4E2M1x2;

let packed = F4E2M1x2::from_f32_pair(3.0, -0.5);
let (a, b) = packed.to_f32_pair();
assert_eq!(a, 3.0);
assert_eq!(b, -0.5);

Trait Implementations

impl Clone for F4E2M1x2

fn clone(&self) -> F4E2M1x2

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for F4E2M1x2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for F4E2M1x2

fn default() -> F4E2M1x2

Returns the “default value” for a type.

impl Display for F4E2M1x2

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<(F4E2M1, F4E2M1)> for F4E2M1x2

fn from((lo, hi): (F4E2M1, F4E2M1)) -> Self

Converts to this type from the input type.

impl From<F4E2M1x2> for (F4E2M1, F4E2M1)

fn from(packed: F4E2M1x2) -> Self

Converts to this type from the input type.

impl Hash for F4E2M1x2

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for F4E2M1x2

fn eq(&self, other: &F4E2M1x2) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for F4E2M1x2

impl Eq for F4E2M1x2

impl StructuralPartialEq for F4E2M1x2