Struct float16 

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

IEEE 754 binary16 (half-precision) floating-point type.

This is a 16-bit floating-point format with:

• 1 sign bit
• 5 exponent bits (bias = 15)
• 10 mantissa bits (with implicit leading 1 for normalized values)

Special values:

• ±0: exponent = 0, mantissa = 0
• ±Inf: exponent = 31, mantissa = 0
• NaN: exponent = 31, mantissa ≠ 0
• Subnormals: exponent = 0, mantissa ≠ 0

Implementations

impl float16

pub const ZERO: Self

Positive zero (+0.0).

pub const NEG_ZERO: Self

Negative zero (-0.0).

pub const INFINITY: Self

Positive infinity.

pub const NEG_INFINITY: Self

Negative infinity.

pub const NAN: Self

Quiet NaN (canonical).

pub const MAX: Self

Maximum finite value (65504.0).

pub const MIN_POSITIVE: Self

Minimum positive normal value (2^-14 ≈ 6.104e-5).

pub const MIN_POSITIVE_SUBNORMAL: Self

Minimum positive subnormal value (2^-24 ≈ 5.96e-8).

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

Create a float16 from raw bits.

This is a const function that performs no validation.

pub const fn to_bits(self) -> u16

Extract the raw bit representation.

pub fn from_f32(value: f32) -> Self

Convert f32 to float16 using IEEE 754 round-to-nearest, ties-to-even.

Handles:

• NaN → NaN (preserves payload bits where possible, ensures quiet NaN)
• ±Inf → ±Inf
• ±0 → ±0 (preserves sign)
• Overflow → ±Inf
• Underflow → subnormal or ±0
• Normal values → rounded to nearest representable value

pub fn to_f32(self) -> f32

Convert float16 to f32 (exact conversion).

All float16 values are exactly representable in f32.

pub fn is_nan(self) -> bool

Returns true if this value is NaN.

pub fn is_infinite(self) -> bool

Returns true if this value is positive or negative infinity.

pub fn is_finite(self) -> bool

Returns true if this value is finite (not NaN or infinity).

pub fn is_normal(self) -> bool

Returns true if this value is a normal number (not zero, subnormal, infinite, or NaN).

pub fn is_subnormal(self) -> bool

Returns true if this value is subnormal.

pub fn is_zero(self) -> bool

Returns true if this value is ±0.

pub fn is_sign_negative(self) -> bool

Returns true if the sign bit is set (negative).

pub fn is_sign_positive(self) -> bool

Returns true if the sign bit is not set (positive).

pub fn eq_value(self, other: Self) -> bool

IEEE-754 numeric equality: NaN != NaN, +0 == -0.

pub fn partial_cmp_value(self, other: Self) -> Option<Ordering>

IEEE-754 partial comparison: returns None if either value is NaN.

pub fn total_cmp(self, other: Self) -> Ordering

Total ordering comparison (including NaN).

This matches the behavior of f32::total_cmp.

pub fn add(self, rhs: Self) -> Self

Add two float16 values (via f32).

pub fn sub(self, rhs: Self) -> Self

Subtract two float16 values (via f32).

pub fn mul(self, rhs: Self) -> Self

Multiply two float16 values (via f32).

pub fn div(self, rhs: Self) -> Self

Divide two float16 values (via f32).

pub fn neg(self) -> Self

Negate this float16 value.

pub fn abs(self) -> Self

Absolute value.

Trait Implementations

impl Add for float16

type Output = float16

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl Clone for float16

fn clone(&self) -> float16

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for float16

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

Formats the value using the given formatter.

impl Default for float16

fn default() -> float16

Returns the “default value” for a type.

impl Display for float16

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

Formats the value using the given formatter.

impl Div for float16

type Output = float16

The resulting type after applying the / operator.

fn div(self, rhs: Self) -> Self

Performs the / operation.

impl ForyDefault for float16

fn fory_default() -> Self

Creates a default value for this type.

impl Hash for float16

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 Mul for float16

type Output = float16

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl Neg for float16

type Output = float16

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for float16

fn eq(&self, other: &Self) -> 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 PartialOrd for float16

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serializer for float16

fn fory_write_data(&self, context: &mut WriteContext<'_>) -> Result<(), Error>

[USER IMPLEMENTATION REQUIRED] Serialize the type’s data to the buffer.

fn fory_read_data(context: &mut ReadContext<'_>) -> Result<Self, Error>

[USER IMPLEMENTATION REQUIRED] Deserialize the type’s data from the buffer.

fn fory_reserved_space() -> usize

Hint for buffer pre-allocation size.

fn fory_get_type_id(_: &TypeResolver) -> Result<TypeId, Error>

Get the registered type ID from the type resolver.

fn fory_type_id_dyn(&self, _: &TypeResolver) -> Result<TypeId, Error>

[USER IMPLEMENTATION REQUIRED] Get the runtime type ID for this instance.

fn fory_static_type_id() -> TypeId

Get the static Fory type ID for this type.

fn as_any(&self) -> &dyn Any

[USER IMPLEMENTATION REQUIRED] Downcast to &dyn Any for dynamic type checking.

fn fory_write_type_info(context: &mut WriteContext<'_>) -> Result<(), Error>

Write type metadata to the buffer.

fn fory_read_type_info(context: &mut ReadContext<'_>) -> Result<(), Error>

Read and validate type metadata from the buffer.

fn fory_write( &self, context: &mut WriteContext<'_>, ref_mode: RefMode, write_type_info: bool, has_generics: bool, ) -> Result<(), Error>

where Self: Sized,

Entry point for serialization.

fn fory_write_data_generic( &self, context: &mut WriteContext<'_>, has_generics: bool, ) -> Result<(), Error>

Write data with generic type parameter support.

fn fory_read( context: &mut ReadContext<'_>, ref_mode: RefMode, read_type_info: bool, ) -> Result<Self, Error>

where Self: Sized + ForyDefault,

Entry point for deserialization.

fn fory_read_with_type_info( context: &mut ReadContext<'_>, ref_mode: RefMode, type_info: Rc<TypeInfo>, ) -> Result<Self, Error>

where Self: Sized + ForyDefault,

Deserialize with pre-read type information.

fn fory_is_option() -> bool

where Self: Sized,

Check if this type is Option<T>.

fn fory_is_none(&self) -> bool

Check if this instance represents a None value.

fn fory_is_polymorphic() -> bool

where Self: Sized,

Check if this type supports polymorphic serialization.

fn fory_is_shared_ref() -> bool

where Self: Sized,

Check if this type is a shared reference (Rc/Arc).

fn fory_is_wrapper_type() -> bool

where Self: Sized,

fn fory_get_type_info( type_resolver: &TypeResolver, ) -> Result<Rc<TypeInfo>, Error>

where Self: Sized,

fn fory_concrete_type_id(&self) -> TypeId

Get Rust’s std::any::TypeId for this instance.

impl Sub for float16

type Output = float16

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl Copy for float16

impl Eq for float16