Trait FloatArray 

pub trait FloatArray<T: ArrowFloatType + ?Sized>:
    Array
    + Clone
    + 'static {
    type FloatType: ArrowFloatType;

    // Required methods
    fn as_slice(&self) -> &[T::Native];
    fn from_values(values: Vec<T::Native>) -> Self;

    // Provided method
    fn from_iter_values(values: impl IntoIterator<Item = T::Native>) -> Self
       where Self: Sized { ... }
}

FloatArray is a trait that is implemented by all float type arrays

This is similar to arrow_array::PrimitiveArray but applies to all float types (including bfloat16) and is implemented as a trait and not a struct

Required Associated Types

type FloatType: ArrowFloatType

Required Methods

fn as_slice(&self) -> &[T::Native]

Returns a reference to the underlying data as a slice.

Panics

Implementations may panic if the array’s storage shape does not match the expected element layout. In particular, the bf16 impl panics if value_length() != 2 (the FixedSizeBinary(2) shape required by BFloat16Array).

Preconditions

Implementations may impose additional invariants on the underlying buffer. The bf16 impl requires the value buffer to be at least 2-byte aligned — satisfied automatically by every in-tree Lance constructor, but external callers passing externally-built arrays (FFI, IPC, Buffer::from_custom_allocation) must ensure alignment. See the impl’s docstring for details.

fn from_values(values: Vec<T::Native>) -> Self

Construct an array from a vector of values.

Provided Methods

fn from_iter_values(values: impl IntoIterator<Item = T::Native>) -> Self

where Self: Sized,

Construct an array from an iterator of values.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl FloatArray<BFloat16Type> for FixedSizeBinaryArray

fn as_slice(&self) -> &[bf16]

Returns the underlying bf16 values as a borrowed slice.

Preconditions

• value_length() must be 2 (the FixedSizeBinary(2) storage shape used by BFloat16Array). Asserted at entry.
• The value buffer must be at least 2-byte aligned. Lance’s in-tree constructors always satisfy this: value buffers are built either via MutableBuffer (aligned to arrow-buffer’s ALIGNMENT constant, ≥32 bytes) or via Buffer::from_vec::<u16> (aligned to align_of::<u16>() == 2); both meet bf16’s 2-byte requirement. Externally-built FixedSizeBinaryArrays arriving via FFI, IPC, or Buffer::from_custom_allocation are not required by arrow-rs to be aligned beyond a single byte; passing one to this method violates the precondition. A debug_assert below catches such inputs in debug and test builds.

Endianness

lance-arrow is gated on target_endian = "little" at the crate root, so this method always returns values in the same byte order Lance writes (see BFloat16Array::value and the FromIterator impls).

type FloatType = BFloat16Type

fn from_values(values: Vec<bf16>) -> Self

impl FloatArray<Float16Type> for Float16Array

type FloatType = Float16Type

fn as_slice(&self) -> &[<Float16Type as ArrowFloatType>::Native]

fn from_values(values: Vec<<Float16Type as ArrowFloatType>::Native>) -> Self

impl FloatArray<Float32Type> for Float32Array

type FloatType = Float32Type

fn as_slice(&self) -> &[<Float32Type as ArrowFloatType>::Native]

fn from_values(values: Vec<<Float32Type as ArrowFloatType>::Native>) -> Self

impl FloatArray<Float64Type> for Float64Array

type FloatType = Float64Type

fn as_slice(&self) -> &[<Float64Type as ArrowFloatType>::Native]

fn from_values(values: Vec<<Float64Type as ArrowFloatType>::Native>) -> Self

Implementors