Struct polars::prelude::ChunkedArray

source ·

pub struct ChunkedArray<T>where
    T: PolarsDataType,
{ /* private fields */ }

Expand description

§ChunkedArray

Every Series contains a ChunkedArray<T>. Unlike Series, ChunkedArrays are typed. This allows us to apply closures to the data and collect the results to a ChunkedArray of the same type T. Below we use an apply to use the cosine function to the values of a ChunkedArray.

fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
    ca.apply_values_generic(|v| v.cos() as f64)
}

§Conversion between Series and ChunkedArray’s

Conversion from a Series to a ChunkedArray is effortless.

fn to_chunked_array(series: &Series) -> PolarsResult<&Int32Chunked>{
    series.i32()
}

fn to_series(ca: Int32Chunked) -> Series {
    ca.into_series()
}

§Iterators

ChunkedArrays fully support Rust native Iterator and DoubleEndedIterator traits, thereby giving access to all the excellent methods available for Iterators.


fn iter_forward(ca: &Float32Chunked) {
    ca.iter()
        .for_each(|opt_v| println!("{:?}", opt_v))
}

fn iter_backward(ca: &Float32Chunked) {
    ca.iter()
        .rev()
        .for_each(|opt_v| println!("{:?}", opt_v))
}

§Memory layout

ChunkedArrays use Apache Arrow as backend for the memory layout. Arrows memory is immutable which makes it possible to make multiple zero copy (sub)-views from a single array.

To be able to append data, Polars uses chunks to append new memory locations, hence the ChunkedArray<T> data structure. Appends are cheap, because it will not lead to a full reallocation of the whole array (as could be the case with a Rust Vec).

However, multiple chunks in a ChunkedArray will slow down many operations that need random access because we have an extra indirection and indexes need to be mapped to the proper chunk. Arithmetic may also be slowed down by this. When multiplying two ChunkedArrays with different chunk sizes they cannot utilize SIMD for instance.

If you want to have predictable performance (no unexpected re-allocation of memory), it is advised to call the ChunkedArray::rechunk after multiple append operations.

See also ChunkedArray::extend for appends within a chunk.

§Invariants

A ChunkedArray should always have at least a single ArrayRef.
The PolarsDataType T should always map to the correct ArrowDataType in the ArrayRef chunks.
Nested datatypes such as List and [Array] store the physical types instead of the logical type given by the datatype.

Struct polars::prelude::ChunkedArrayCopy item path

§ChunkedArray

§Conversion between Series and ChunkedArray’s

§Iterators

§Memory layout

§Invariants

Implementations§

impl ChunkedArray<BooleanType>

pub fn sum(&self) -> Option<u32>

pub fn min(&self) -> Option<bool>

pub fn max(&self) -> Option<bool>

pub fn mean(&self) -> Option<f64>

impl<T> ChunkedArray<T>where T: PolarsDataType<IsNested = FalseT>, <T as PolarsDataType>::Physical<'a>: for<'a> TotalOrd,

pub fn append(&mut self, other: &ChunkedArray<T>)

impl<T> ChunkedArray<T>where T: PolarsDataType,

pub fn apply_values_generic<'a, U, K, F>(&'a self, op: F) -> ChunkedArray<U>where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIter<K>,

pub fn apply_nonnull_values_generic<'a, U, K, F>( &'a self, dtype: DataType, op: F ) -> ChunkedArray<U>where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIterDtype<K> + ArrayFromIterDtype<Option<K>>,

pub fn try_apply_nonnull_values_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> Result<K, E>, <U as PolarsDataType>::Array: ArrayFromIter<K> + ArrayFromIter<Option<K>>,

pub fn apply_generic<'a, U, K, F>(&'a self, op: F) -> ChunkedArray<U>where U: PolarsDataType, F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>) -> Option<K>, <U as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

pub fn try_apply_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>where U: PolarsDataType, F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>) -> Result<Option<K>, E> + Copy, <U as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

impl<T> ChunkedArray<T>where T: PolarsNumericType,

pub fn cast_and_apply_in_place<F, S>(&self, f: F) -> ChunkedArray<S>where F: Fn(<S as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy, S: PolarsNumericType,

pub fn apply_in_place<F>(self, f: F) -> ChunkedArray<T>where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

impl<T> ChunkedArray<T>where T: PolarsNumericType,

pub fn apply_mut<F>(&mut self, f: F)where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

impl ChunkedArray<StringType>

pub fn apply_mut<'a, F>(&'a self, f: F) -> ChunkedArray<StringType>where F: FnMut(&'a str) -> &'a str,

pub fn apply_to_buffer<'a, F>(&'a self, f: F) -> ChunkedArray<StringType>where F: FnMut(&'a str, &mut String),

impl ChunkedArray<BinaryType>

pub fn apply_mut<'a, F>(&'a self, f: F) -> ChunkedArray<BinaryType>where F: FnMut(&'a [u8]) -> &'a [u8],

impl ChunkedArray<Float32Type>

pub fn apply_as_ints<F>(&self, f: F) -> Serieswhere F: Fn(&Series) -> Series,

impl ChunkedArray<Float64Type>

pub fn apply_as_ints<F>(&self, f: F) -> Serieswhere F: Fn(&Series) -> Series,

impl<T> ChunkedArray<T>where T: PolarsDataType,

pub fn len(&self) -> usize

pub fn null_count(&self) -> usize

pub unsafe fn set_null_count(&mut self, null_count: u32)

§Safety

pub fn is_empty(&self) -> bool

pub fn rechunk(&self) -> ChunkedArray<T>

pub fn slice(&self, offset: i64, length: usize) -> ChunkedArray<T>

pub fn limit(&self, num_elements: usize) -> ChunkedArray<T>where ChunkedArray<T>: Sized,

pub fn head(&self, length: Option<usize>) -> ChunkedArray<T>where ChunkedArray<T>: Sized,

pub fn tail(&self, length: Option<usize>) -> ChunkedArray<T>where ChunkedArray<T>: Sized,

pub fn prune_empty_chunks(&mut self)

impl ChunkedArray<StringType>

pub fn to_decimal(&self, infer_length: usize) -> Result<Series, PolarsError>

impl<T> ChunkedArray<T>where T: PolarsNumericType,

pub fn extend(&mut self, other: &ChunkedArray<T>)

impl<T> ChunkedArray<T>where T: PolarsDataType,

pub fn for_each<'a, F>(&'a self, op: F)where F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>),

impl ChunkedArray<FixedSizeListType>

pub fn full_null_with_dtype( name: &str, length: usize, inner_dtype: &DataType, width: usize ) -> ChunkedArray<FixedSizeListType>

impl ChunkedArray<ListType>

pub fn full_null_with_dtype( name: &str, length: usize, inner_dtype: &DataType ) -> ChunkedArray<ListType>

impl ChunkedArray<UInt32Type>

pub fn with_nullable_idx<T, F>(idx: &[NullableIdxSize], f: F) -> Twhere F: FnOnce(&ChunkedArray<UInt32Type>) -> T,

impl<T> ChunkedArray<T>where T: PolarsDataType,

pub fn is_null(&self) -> ChunkedArray<BooleanType>

pub fn is_not_null(&self) -> ChunkedArray<BooleanType>

impl<T> ChunkedArray<T>where ChunkedArray<T>: IntoSeries, T: PolarsFloatType, <T as PolarsNumericType>::Native: Float + IsFloat + SubAssign + Pow<<T as PolarsNumericType>::Native, Output = <T as PolarsNumericType>::Native>,

pub fn rolling_map_float<F>( &self, window_size: usize, f: F ) -> Result<ChunkedArray<T>, PolarsError>where F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,

impl ChunkedArray<BinaryType>

pub unsafe fn to_string_unchecked(&self) -> ChunkedArray<StringType>

§Safety

impl ChunkedArray<StringType>

pub fn as_binary(&self) -> ChunkedArray<BinaryType>

impl ChunkedArray<BooleanType>

pub fn any(&self) -> bool

pub fn all(&self) -> bool

pub fn any_kleene(&self) -> Option<bool>

pub fn all_kleene(&self) -> Option<bool>

impl<T> ChunkedArray<T>where T: PolarsFloatType, <T as PolarsNumericType>::Native: Float,

pub fn is_nan(&self) -> ChunkedArray<BooleanType>

pub fn is_not_nan(&self) -> ChunkedArray<BooleanType>

pub fn is_finite(&self) -> ChunkedArray<BooleanType>

pub fn is_infinite(&self) -> ChunkedArray<BooleanType>

pub fn none_to_nan(&self) -> ChunkedArray<T>

impl<T> ChunkedArray<T>where T: PolarsFloatType, <T as PolarsNumericType>::Native: Float + Canonical,

Struct polars::prelude::ChunkedArray

impl<T> ChunkedArray<T>
where T: PolarsDataType<IsNested = FalseT>, <T as PolarsDataType>::Physical<'a>: for<'a> TotalOrd,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

pub fn apply_values_generic<'a, U, K, F>(&'a self, op: F) -> ChunkedArray<U>
where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIter<K>,

pub fn apply_nonnull_values_generic<'a, U, K, F>( &'a self, dtype: DataType, op: F ) -> ChunkedArray<U>
where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIterDtype<K> + ArrayFromIterDtype<Option<K>>,

pub fn try_apply_nonnull_values_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>
where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> Result<K, E>, <U as PolarsDataType>::Array: ArrayFromIter<K> + ArrayFromIter<Option<K>>,

pub fn apply_generic<'a, U, K, F>(&'a self, op: F) -> ChunkedArray<U>
where U: PolarsDataType, F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>) -> Option<K>, <U as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

pub fn try_apply_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>
where U: PolarsDataType, F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>) -> Result<Option<K>, E> + Copy, <U as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

impl<T> ChunkedArray<T>
where T: PolarsNumericType,

pub fn cast_and_apply_in_place<F, S>(&self, f: F) -> ChunkedArray<S>
where F: Fn(<S as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy, S: PolarsNumericType,

pub fn apply_in_place<F>(self, f: F) -> ChunkedArray<T>
where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

impl<T> ChunkedArray<T>
where T: PolarsNumericType,

pub fn apply_mut<F>(&mut self, f: F)
where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

pub fn apply_mut<'a, F>(&'a self, f: F) -> ChunkedArray<StringType>
where F: FnMut(&'a str) -> &'a str,

pub fn apply_to_buffer<'a, F>(&'a self, f: F) -> ChunkedArray<StringType>
where F: FnMut(&'a str, &mut String),

pub fn apply_mut<'a, F>(&'a self, f: F) -> ChunkedArray<BinaryType>
where F: FnMut(&'a [u8]) -> &'a [u8],

pub fn apply_as_ints<F>(&self, f: F) -> Series
where F: Fn(&Series) -> Series,

pub fn apply_as_ints<F>(&self, f: F) -> Series
where F: Fn(&Series) -> Series,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

pub fn limit(&self, num_elements: usize) -> ChunkedArray<T>
where ChunkedArray<T>: Sized,

pub fn head(&self, length: Option<usize>) -> ChunkedArray<T>
where ChunkedArray<T>: Sized,

pub fn tail(&self, length: Option<usize>) -> ChunkedArray<T>
where ChunkedArray<T>: Sized,

impl<T> ChunkedArray<T>
where T: PolarsNumericType,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

pub fn for_each<'a, F>(&'a self, op: F)
where F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>),

pub fn with_nullable_idx<T, F>(idx: &[NullableIdxSize], f: F) -> T
where F: FnOnce(&ChunkedArray<UInt32Type>) -> T,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

impl<T> ChunkedArray<T>
where ChunkedArray<T>: IntoSeries, T: PolarsFloatType, <T as PolarsNumericType>::Native: Float + IsFloat + SubAssign + Pow<<T as PolarsNumericType>::Native, Output = <T as PolarsNumericType>::Native>,

pub fn rolling_map_float<F>( &self, window_size: usize, f: F ) -> Result<ChunkedArray<T>, PolarsError>
where F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,

impl<T> ChunkedArray<T>
where T: PolarsFloatType, <T as PolarsNumericType>::Native: Float,

impl<T> ChunkedArray<T>
where T: PolarsFloatType, <T as PolarsNumericType>::Native: Float + Canonical,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

impl<T> ChunkedArray<T>
where T: PolarsNumericType,

pub fn to_ndarray<N>( &self ) -> Result<ArrayBase<OwnedRepr<<N as PolarsNumericType>::Native>, Dim<[usize; 2]>>, PolarsError>
where N: PolarsNumericType,

pub fn try_apply_amortized_to_list<F>( &self, f: F ) -> Result<ChunkedArray<ListType>, PolarsError>
where F: FnMut(AmortSeries) -> Result<Series, PolarsError>,

pub unsafe fn apply_amortized_same_type<F>( &self, f: F ) -> ChunkedArray<FixedSizeListType>
where F: FnMut(AmortSeries) -> Series,

pub unsafe fn try_apply_amortized_same_type<F>( &self, f: F ) -> Result<ChunkedArray<FixedSizeListType>, PolarsError>
where F: FnMut(AmortSeries) -> Result<Series, PolarsError>,

pub unsafe fn zip_and_apply_amortized_same_type<'a, T, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> ChunkedArray<FixedSizeListType>
where T: PolarsDataType, F: FnMut(Option<AmortSeries>, Option<<T as PolarsDataType>::Physical<'a>>) -> Option<Series>,

pub fn apply_amortized_generic<F, K, V>(&self, f: F) -> ChunkedArray<V>
where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> Option<K> + Copy, <V as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

pub fn try_apply_amortized_generic<F, K, V>( &self, f: F ) -> Result<ChunkedArray<V>, PolarsError>
where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> Result<Option<K>, PolarsError> + Copy, <V as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

pub fn for_each_amortized<F>(&self, f: F)
where F: FnMut(Option<AmortSeries>),

impl<T> ChunkedArray<T>
where T: PolarsDataType, <<T as PolarsDataType>::Array as StaticArray>::ValueT<'a>: for<'a> AsRef<[u8]>,

impl<T> ChunkedArray<T>
where T: PolarsDataType,

pub fn with_chunk<A>(name: &str, arr: A) -> ChunkedArray<T>
where A: Array, T: PolarsDataType<Array = A>,

pub fn with_chunk_like<A>(ca: &ChunkedArray<T>, arr: A) -> ChunkedArray<T>
where A: Array, T: PolarsDataType<Array = A>,

pub fn from_chunk_iter<I>(name: &str, iter: I) -> ChunkedArray<T>
where I: IntoIterator, T: PolarsDataType<Array = <I as IntoIterator>::Item>, <I as IntoIterator>::Item: Array,

pub fn from_chunk_iter_like<I>(ca: &ChunkedArray<T>, iter: I) -> ChunkedArray<T>
where I: IntoIterator, T: PolarsDataType<Array = <I as IntoIterator>::Item>, <I as IntoIterator>::Item: Array,

pub fn try_from_chunk_iter<I, A, E>( name: &str, iter: I ) -> Result<ChunkedArray<T>, E>
where I: IntoIterator<Item = Result<A, E>>, T: PolarsDataType<Array = A>, A: Array,

impl<T> ChunkedArray<T>
where T: PolarsNumericType,

pub fn apply_amortized_generic<F, K, V>(&self, f: F) -> ChunkedArray<V>
where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> Option<K> + Copy, <V as PolarsDataType>::Array: ArrayFromIter<Option<K>>,

pub fn try_apply_amortized_generic<F, K, V>( &self, f: F ) -> Result<ChunkedArray<V>, PolarsError>
where V: PolarsDataType, F: FnMut(Option<AmortSeries>) -> Result<Option<K>, PolarsError> + Copy, <V as PolarsDataType>::Array: ArrayFromIter<Option<K>>,