Required Methods

fn reinterpret_cast(&self) -> &[u16]

Reinterprets a slice of [struct@f16] or [struct@bf16] numbers as a slice of u16 bits.

This is a zero-copy operation. The reinterpreted slice has the same lifetime and memory location as self.

Examples

# use half::prelude::*;
let float_buffer = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)];
let int_buffer = float_buffer.reinterpret_cast();

assert_eq!(int_buffer, [float_buffer[0].to_bits(), float_buffer[1].to_bits(), float_buffer[2].to_bits()]);

fn reinterpret_cast_mut(&mut self) -> &mut [u16]

Reinterprets a mutable slice of [struct@f16] or [struct@bf16] numbers as a mutable slice of u16. bits

This is a zero-copy operation. The transmuted slice has the same lifetime as the original, which prevents mutating self as long as the returned &mut [u16] is borrowed.

Examples

# use half::prelude::*;
let mut float_buffer = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.)];

{
    let int_buffer = float_buffer.reinterpret_cast_mut();

    assert_eq!(int_buffer, [f16::from_f32(1.).to_bits(), f16::from_f32(2.).to_bits(), f16::from_f32(3.).to_bits()]);

    // Mutating the u16 slice will mutating the original
    int_buffer[0] = 0;
}

// Note that we need to drop int_buffer before using float_buffer again or we will get a borrow error.
assert_eq!(float_buffer, [f16::from_f32(0.), f16::from_f32(2.), f16::from_f32(3.)]);

fn convert_from_f32_slice(&mut self, src: &[f32])

Converts all of the elements of a [f32] slice into [struct@f16] or [struct@bf16] values in self.

The length of src must be the same as self.

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

Panics

This function will panic if the two slices have different lengths.

Examples

# use half::prelude::*;
// Initialize an empty buffer
let mut buffer = [0u16; 4];
let buffer = buffer.reinterpret_cast_mut::<f16>();

let float_values = [1., 2., 3., 4.];

// Now convert
buffer.convert_from_f32_slice(&float_values);

assert_eq!(buffer, [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)]);

fn convert_from_f64_slice(&mut self, src: &[f64])

Converts all of the elements of a [f64] slice into [struct@f16] or [struct@bf16] values in self.

The length of src must be the same as self.

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

Panics

This function will panic if the two slices have different lengths.

Examples

# use half::prelude::*;
// Initialize an empty buffer
let mut buffer = [0u16; 4];
let buffer = buffer.reinterpret_cast_mut::<f16>();

let float_values = [1., 2., 3., 4.];

// Now convert
buffer.convert_from_f64_slice(&float_values);

assert_eq!(buffer, [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)]);

fn convert_to_f32_slice(&self, dst: &mut [f32])

Converts all of the [struct@f16] or [struct@bf16] elements of self into f32 values in dst.

The length of src must be the same as self.

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

Panics

This function will panic if the two slices have different lengths.

Examples

# use half::prelude::*;
// Initialize an empty buffer
let mut buffer = [0f32; 4];

let half_values = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)];

// Now convert
half_values.convert_to_f32_slice(&mut buffer);

assert_eq!(buffer, [1., 2., 3., 4.]);

fn convert_to_f64_slice(&self, dst: &mut [f64])

Converts all of the [struct@f16] or [struct@bf16] elements of self into f64 values in dst.

The length of src must be the same as self.

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

Panics

This function will panic if the two slices have different lengths.

Examples

# use half::prelude::*;
// Initialize an empty buffer
let mut buffer = [0f64; 4];

let half_values = [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)];

// Now convert
half_values.convert_to_f64_slice(&mut buffer);

assert_eq!(buffer, [1., 2., 3., 4.]);

fn to_f32_vec(&self) -> Vec<f32>

Converts all of the [struct@f16] or [struct@bf16] elements of self into f32 values in a new vector

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

This method is only available with the std or alloc feature.

Examples

# use half::prelude::*;
let half_values = [f16::from_f32(1.), f16::from_f32(2.), f16::from_f32(3.), f16::from_f32(4.)];
let vec = half_values.to_f32_vec();

assert_eq!(vec, vec![1., 2., 3., 4.]);

fn to_f64_vec(&self) -> Vec<f64>

Converts all of the [struct@f16] or [struct@bf16] elements of self into f64 values in a new vector.

The conversion operation is vectorized over the slice, meaning the conversion may be more efficient than converting individual elements on some hardware that supports SIMD conversions. See crate documentation for more information on hardware conversion support.

This method is only available with the std or alloc feature.

Examples

# use half::prelude::*;
let half_values = [f16::from_f64(1.), f16::from_f64(2.), f16::from_f64(3.), f16::from_f64(4.)];
let vec = half_values.to_f64_vec();

assert_eq!(vec, vec![1., 2., 3., 4.]);