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.

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", so this trait is not object safe.

Implementations on Foreign Types

impl FloatArray<BFloat16Type> for FixedSizeBinaryArray

type FloatType = BFloat16Type

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

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