Struct polars_core::chunked_array::ChunkedArray

pub struct ChunkedArray<T> { /* private fields */ }

ChunkedArray

Every Series contains a ChunkedArray<T>. Unlike Series, ChunkedArray’s 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(ca: &Float32Chunked) -> Float32Chunked {
    ca.apply(|v| v.cos())
}

If we would like to cast the result we could use a Rust Iterator instead of an apply method. Note that Iterators are slightly slower as the null values aren’t ignored implicitly.

fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
    ca.into_iter()
        .map(|opt_v| {
        opt_v.map(|v| v.cos() as f64)
    }).collect()
}

Another option is to first cast and then use an apply.

fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
    ca.apply_cast_numeric(|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) -> Result<&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.into_iter()
        .for_each(|opt_v| println!("{:?}", opt_v))
}

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

Memory layout

ChunkedArray’s 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 ChunkArray will slow down the Iterators, arithmetic and other operations. When multiplying two ChunkArray's with different chunk sizes they cannot utilize SIMD for instance. However, when chunk size don’t match, Iterators will be used to do the operation (instead of arrows upstream implementation, which may utilize SIMD) and the result will be a single chunked array.

The key takeaway is that by applying operations on a ChunkArray of multiple chunks, the results will converge to a ChunkArray of a single chunk! It is recommended to leave them as is. If you want to have predictable performance (no unexpected re-allocation of memory), it is advised to call the rechunk after multiple append operations.

Implementations

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

pub fn abs(&self) -> Self

Convert all values to their absolute/positive value.

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

pub fn append(&mut self, other: &Self)

Append in place.

impl ChunkedArray<BooleanType>

pub fn append(&mut self, other: &Self)

impl ChunkedArray<Utf8Type>

pub fn append(&mut self, other: &Self)

impl ChunkedArray<ListType>

pub fn append(&mut self, other: &Self)

impl<T: PolarsObject> ChunkedArray<ObjectType<T>>

pub fn append(&mut self, other: &Self)

impl ChunkedArray<CategoricalType>

pub fn append(&mut self, other: &Self)

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

pub fn downcast_iter(
    &self
) -> impl Iterator<Item = &PrimitiveArray<T::Native>> + DoubleEndedIterator

pub fn downcast_chunks(&self) -> Chunks<'_, PrimitiveArray<T::Native>>

impl ChunkedArray<BooleanType>

pub fn downcast_iter(
    &self
) -> impl Iterator<Item = &BooleanArray> + DoubleEndedIterator

pub fn downcast_chunks(&self) -> Chunks<'_, BooleanArray>

impl ChunkedArray<Utf8Type>

pub fn downcast_iter(
    &self
) -> impl Iterator<Item = &Utf8Array<i64>> + DoubleEndedIterator

pub fn downcast_chunks(&self) -> Chunks<'_, Utf8Array<i64>>

impl ChunkedArray<ListType>

pub fn downcast_iter(
    &self
) -> impl Iterator<Item = &ListArray<i64>> + DoubleEndedIterator

pub fn downcast_chunks(&self) -> Chunks<'_, ListArray<i64>>

impl<'a, T> ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub fn downcast_iter(
    &self
) -> impl Iterator<Item = &ObjectArray<T>> + DoubleEndedIterator

pub fn downcast_chunks(&self) -> Chunks<'_, ObjectArray<T>>

impl<T> ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Float,
    ChunkedArray<T>: IntoSeries, 

pub fn rolling_mean(&self, options: RollingOptions) -> Result<Series>

Apply a rolling mean (moving mean) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their mean.

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

pub fn rolling_sum(&self, options: RollingOptions) -> Result<Series>

Apply a rolling sum (moving sum) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their sum.

pub fn rolling_median(&self, options: RollingOptions) -> Result<Series>

Apply a rolling median (moving median) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be weighted according to the weights vector.

pub fn rolling_quantile(
    &self,
    quantile: f64,
    interpolation: QuantileInterpolOptions,
    options: RollingOptions
) -> Result<Series>

Apply a rolling quantile (moving quantile) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be weighted according to the weights vector.

pub fn rolling_min(&self, options: RollingOptions) -> Result<Series>

Apply a rolling min (moving min) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their min.

pub fn rolling_max(&self, options: RollingOptions) -> Result<Series>

Apply a rolling max (moving max) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their max.

impl<T> ChunkedArray<T> where
    ChunkedArray<T>: IntoSeries,
    T: PolarsFloatType,
    T::Native: Float, 

pub fn rolling_apply_float<F>(&self, window_size: usize, f: F) -> Result<Self> where
    F: Fn(&ChunkedArray<T>) -> Option<T::Native>, 

Apply a rolling custom function. This is pretty slow because of dynamic dispatch.

pub fn rolling_var(&self, options: RollingOptions) -> Result<Series>

Apply a rolling var (moving var) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their var.

pub fn rolling_std(&self, options: RollingOptions) -> Result<Series>

Apply a rolling std (moving std) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weights vector. The resulting values will be aggregated to their std.

impl ChunkedArray<BooleanType>

pub fn arg_true(&self) -> UInt32Chunked

impl ChunkedArray<BooleanType>

pub fn all(&self) -> bool

Check if all values are true

pub fn any(&self) -> bool

Check if any value is true

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

pub fn is_nan(&self) -> BooleanChunked

pub fn is_not_nan(&self) -> BooleanChunked

pub fn is_finite(&self) -> BooleanChunked

pub fn is_infinite(&self) -> BooleanChunked

pub fn none_to_nan(&self) -> Self

Convert missing values to NaN values.

impl ChunkedArray<BooleanType>

pub fn into_no_null_iter(
    &self
) -> impl Iterator<Item = bool> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

impl ChunkedArray<Utf8Type>

pub fn into_no_null_iter<'a>(
    &'a self
) -> impl Iterator<Item = &'a str> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

impl ChunkedArray<ListType>

pub fn into_no_null_iter(
    &self
) -> impl Iterator<Item = Series> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

impl<T: PolarsObject> ChunkedArray<ObjectType<T>>

pub fn into_no_null_iter(
    &self
) -> impl Iterator<Item = &T> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

impl ChunkedArray<CategoricalType>

pub fn into_no_null_iter(
    &self
) -> impl Iterator<Item = u32> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

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

pub fn to_ndarray(&self) -> Result<ArrayView1<'_, T::Native>>

This is supported on crate feature ndarray only.

If data is aligned in a single chunk and has no Null values a zero copy view is returned as an ndarray

impl ChunkedArray<ListType>

pub fn to_ndarray<N>(&self) -> Result<Array2<N::Native>> where
    N: PolarsNumericType, 

This is supported on crate feature ndarray only.

If all nested Series have the same length, a 2 dimensional ndarray::Array is returned.

impl ChunkedArray<CategoricalType>

pub fn get_categorical_map(&self) -> Option<&Arc<RevMapping>>

Get a reference to the mapping of categorical types to the string values.

pub fn iter_str(&self) -> CatIter<'_>

Create an [Iterator] that iterates over the &str values of the [CategoricalChunked].

impl ChunkedArray<ListType>

pub fn amortized_iter(
    &self
) -> AmortizedListIter<'_, impl Iterator<Item = Option<ArrayBox>> + '_>

This is an iterator over a ListChunked that save allocations. A Series is: 1. Arc ChunkedArray is: 2. Vec< 3. ArrayRef>

The ArrayRef we indicated with 3. will be updated during iteration. The Series will be pinned in memory, saving an allocation for

1. Arc<..>
2. Vec<…>

Warning

Though memory safe in the sense that it will not read unowned memory, UB, or memory leaks this function still needs precautions. The returned should never be cloned or taken longer than a single iteration, as every call on next of the iterator will change the contents of that Series.

pub fn apply_amortized<'a, F>(&'a self, f: F) -> Self where
    F: FnMut(UnstableSeries<'a>) -> Series, 

Apply a closure F elementwise.

pub fn try_apply_amortized<'a, F>(&'a self, f: F) -> Result<Self> where
    F: FnMut(UnstableSeries<'a>) -> Result<Series>, 

impl ChunkedArray<ListType>

pub fn lst_max(&self) -> Series

pub fn lst_min(&self) -> Series

pub fn lst_sum(&self) -> Series

pub fn lst_mean(&self) -> Float64Chunked

pub fn lst_sort(&self, reverse: bool) -> ListChunked

pub fn lst_reverse(&self) -> ListChunked

pub fn lst_unique(&self) -> Result<ListChunked>

pub fn lst_lengths(&self) -> UInt32Chunked

pub fn lst_get(&self, idx: i64) -> Result<Series>

Get the value by index in the sublists. So index 0 would return the first item of every sublist and index -1 would return the last item of every sublist if an index is out of bounds, it will return a None.

pub fn lst_concat(&self, other: &[Series]) -> Result<ListChunked>

impl ChunkedArray<ListType>

pub fn set_fast_explode(&mut self)

pub fn to_logical(&mut self, inner_dtype: DataType)

impl ChunkedArray<Int32Type>

pub fn into_date(self) -> DateChunked

impl ChunkedArray<Int64Type>

pub fn into_datetime(
    self,
    timeunit: TimeUnit,
    tz: Option<TimeZone>
) -> DatetimeChunked

impl ChunkedArray<Int64Type>

pub fn into_duration(self, timeunit: TimeUnit) -> DurationChunked

impl ChunkedArray<Int64Type>

pub fn into_time(self) -> TimeChunked

impl<T> ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub fn new_from_vec(name: &str, v: Vec<T>) -> Self

This is supported on crate feature object only.

impl<T> ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub unsafe fn get_object_unchecked(
    &self,
    index: usize
) -> Option<&dyn PolarsObjectSafe>

This is supported on crate feature object only.

Get a hold to an object that can be formatted or downcasted via the Any trait.

Safety

No bounds checks

pub fn get_object(&self, index: usize) -> Option<&dyn PolarsObjectSafe>

This is supported on crate feature object only.

Get a hold to an object that can be formatted or downcasted via the Any trait.

impl<T> ChunkedArray<T> where
    T: PolarsNumericType,
    Standard: Distribution<T::Native>, 

pub fn init_rand(size: usize, null_density: f32, seed: u64) -> Self

This is supported on crate feature random only.

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

pub fn sample_n(
    &self,
    n: usize,
    with_replacement: bool,
    seed: u64
) -> Result<Self>

This is supported on crate feature random only.

Sample n datapoints from this ChunkedArray.

pub fn sample_frac(
    &self,
    frac: f64,
    with_replacement: bool,
    seed: u64
) -> Result<Self>

This is supported on crate feature random only.

Sample a fraction between 0.0-1.0 of this ChunkedArray.

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

pub fn rand_normal(
    name: &str,
    length: usize,
    mean: f64,
    std_dev: f64
) -> Result<Self>

This is supported on crate feature random only.

Create ChunkedArray with samples from a Normal distribution.

pub fn rand_standard_normal(name: &str, length: usize) -> Self

This is supported on crate feature random only.

Create ChunkedArray with samples from a Standard Normal distribution.

pub fn rand_uniform(name: &str, length: usize, low: f64, high: f64) -> Self

This is supported on crate feature random only.

Create ChunkedArray with samples from a Uniform distribution.

impl ChunkedArray<BooleanType>

pub fn rand_bernoulli(name: &str, length: usize, p: f64) -> Result<Self>

This is supported on crate feature random only.

Create ChunkedArray with samples from a Bernoulli distribution.

impl ChunkedArray<Utf8Type>

pub fn json_path_match(&self, json_path: &str) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

Extract json path, first match Refer to https://goessner.net/articles/JsonPath/

impl ChunkedArray<Utf8Type>

pub fn hex_decode(&self, strict: Option<bool>) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

pub fn hex_encode(&self) -> Utf8Chunked

This is supported on crate feature strings only.

pub fn base64_decode(&self, strict: Option<bool>) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

pub fn base64_encode(&self) -> Utf8Chunked

This is supported on crate feature strings only.

impl ChunkedArray<Utf8Type>

pub fn str_lengths(&self) -> UInt32Chunked

This is supported on crate feature strings only.

Get the length of the string values.

pub fn contains(&self, pat: &str) -> Result<BooleanChunked>

This is supported on crate feature strings only.

Check if strings contain a regex pattern

pub fn replace(&self, pat: &str, val: &str) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

Replace the leftmost (sub)string by a regex pattern

pub fn replace_all(&self, pat: &str, val: &str) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

Replace all (sub)strings by a regex pattern

pub fn extract(&self, pat: &str, group_index: usize) -> Result<Utf8Chunked>

This is supported on crate feature strings only.

Extract the nth capture group from pattern

pub fn to_lowercase(&self) -> Utf8Chunked

This is supported on crate feature strings only.

Modify the strings to their lowercase equivalent

pub fn to_uppercase(&self) -> Utf8Chunked

This is supported on crate feature strings only.

Modify the strings to their uppercase equivalent

pub fn concat(&self, other: &Utf8Chunked) -> Self

This is supported on crate feature strings only.

Concat with the values from a second Utf8Chunked

pub fn str_slice(&self, start: i64, length: Option<u64>) -> Result<Self>

This is supported on crate feature strings only.

Slice the string values Determines a substring starting from start and with optional length length of each of the elements in array. start can be negative, in which case the start counts from the end of the string.

impl<T> ChunkedArray<T>

pub fn first_non_null(&self) -> Option<usize>

Get the index of the first non null value in this ChunkedArray.

pub fn iter_validities(&self) -> impl Iterator<Item = Option<&Bitmap>> + '_

Get the buffer of bits representing null values

pub fn has_validity(&self) -> bool

Return if any the chunks in this [ChunkedArray] have a validity bitmap. no bitmap means no null values.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit it’s length.

pub fn unpack_series_matching_type(
    &self,
    series: &Series
) -> Result<&ChunkedArray<T>>

Series to ChunkedArray

pub fn chunk_id(&self) -> ChunkIdIter<'_>

Unique id representing the number of chunks

pub fn chunks(&self) -> &Vec<ArrayRef>

A reference to the chunks

pub fn is_optimal_aligned(&self) -> bool

Returns true if contains a single chunk and has no null values

pub fn null_count(&self) -> usize

Count the null values.

pub fn append_array(&mut self, other: ArrayRef) -> Result<()>

Append arrow array in place.

let mut array = Int32Chunked::new("array", &[1, 2]);
let array_2 = Int32Chunked::new("2nd", &[3]);

array.append(&array_2);
assert_eq!(Vec::from(&array), [Some(1), Some(2), Some(3)])

pub fn is_null(&self) -> BooleanChunked

Get a mask of the null values.

pub fn is_not_null(&self) -> BooleanChunked

Get a mask of the valid values.

pub fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

pub fn name(&self) -> &str

Name of the ChunkedArray.

pub fn ref_field(&self) -> &Field

Get a reference to the field.

pub fn rename(&mut self, name: &str)

Rename this ChunkedArray.

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

pub fn new_from_chunks(name: &str, chunks: Vec<ArrayRef>) -> Self

Create a new ChunkedArray from existing chunks.

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

pub fn new_from_aligned_vec(name: &str, v: Vec<T::Native>) -> Self

Create a new ChunkedArray by taking ownership of the Vec. This operation is zero copy.

pub fn new_from_owned_with_null_bitmap(
    name: &str,
    values: Vec<T::Native>,
    buffer: Option<Bitmap>
) -> Self

Nullify values in slice with an existing null bitmap

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

pub fn cont_slice(&self) -> Result<&[T::Native]>

Contiguous slice

pub fn data_views(
    &self
) -> impl Iterator<Item = &[T::Native]> + DoubleEndedIterator

Get slices of the underlying arrow data. NOTE: null values should be taken into account by the user of these slices as they are handled separately

pub fn into_no_null_iter(
    &self
) -> impl Iterator<Item = T::Native> + '_ + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

impl ChunkedArray<ListType>

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the list.

impl<T: PolarsNumericType> ChunkedArray<T>

pub fn new_vec(name: &str, v: Vec<T::Native>) -> Self

Specialization that prevents an allocation prefer this over ChunkedArray::new when you have a Vec<T::Native> and no null values.

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

We cannot override the left hand side behaviour. So we create a trait LhsNumOps. This allows for 1.add(&Series)

pub fn lhs_sub<N: Num + NumCast>(&self, lhs: N) -> Self

Apply lhs - self

pub fn lhs_div<N: Num + NumCast>(&self, lhs: N) -> Self

Apply lhs / self

pub fn lhs_rem<N: Num + NumCast>(&self, lhs: N) -> Self

Apply lhs % self

Trait Implementations

impl<T> Add<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsNumericType, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<&'_ ChunkedArray<Utf8Type>> for &Utf8Chunked

type Output = Utf8Chunked

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<ChunkedArray<Utf8Type>> for Utf8Chunked

type Output = Utf8Chunked

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, N> Add<N> for &ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, N> Add<N> for ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> AggList for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: IntoSeries, 

fn agg_list(&self, groups: &[(u32, Vec<u32>)]) -> Option<Series>

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

fn arg_min(&self) -> Option<usize>

Get the index of the minimal value

fn arg_max(&self) -> Option<usize>

Get the index of the maximal value

impl<'a, T> AsMut<ChunkedArray<T>> for dyn SeriesTrait + 'a where
    T: 'static + PolarsDataType, 

fn as_mut(&mut self) -> &mut ChunkedArray<T>

Performs the conversion.

impl<T> AsRef<ChunkedArray<T>> for ChunkedArray<T>

fn as_ref(&self) -> &ChunkedArray<T>

Performs the conversion.

impl<'a, T> AsRef<ChunkedArray<T>> for dyn SeriesTrait + 'a where
    T: 'static + PolarsDataType, 

fn as_ref(&self) -> &ChunkedArray<T>

Performs the conversion.

impl BitAnd<&'_ ChunkedArray<BooleanType>> for &BooleanChunked

type Output = BooleanChunked

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAnd<&'_ ChunkedArray<Float32Type>> for &Float32Chunked

type Output = Float32Chunked

The resulting type after applying the & operator.

fn bitand(self, _rhs: Self) -> Self::Output

Performs the & operation.

impl BitAnd<&'_ ChunkedArray<Float64Type>> for &Float64Chunked

type Output = Float64Chunked

The resulting type after applying the & operator.

fn bitand(self, _rhs: Self) -> Self::Output

Performs the & operation.

impl<T> BitAnd<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: BitAnd<Output = T::Native>, 

type Output = ChunkedArray<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAnd<ChunkedArray<BooleanType>> for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitOr<&'_ ChunkedArray<BooleanType>> for &BooleanChunked

type Output = BooleanChunked

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOr<&'_ ChunkedArray<Float32Type>> for &Float32Chunked

type Output = Float32Chunked

The resulting type after applying the | operator.

fn bitor(self, _rhs: Self) -> Self::Output

Performs the | operation.

impl BitOr<&'_ ChunkedArray<Float64Type>> for &Float64Chunked

type Output = Float64Chunked

The resulting type after applying the | operator.

fn bitor(self, _rhs: Self) -> Self::Output

Performs the | operation.

impl<T> BitOr<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: BitOr<Output = T::Native>, 

type Output = ChunkedArray<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOr<ChunkedArray<BooleanType>> for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitXor<&'_ ChunkedArray<BooleanType>> for &BooleanChunked

type Output = BooleanChunked

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXor<&'_ ChunkedArray<Float32Type>> for &Float32Chunked

type Output = Float32Chunked

The resulting type after applying the ^ operator.

fn bitxor(self, _rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXor<&'_ ChunkedArray<Float64Type>> for &Float64Chunked

type Output = Float64Chunked

The resulting type after applying the ^ operator.

fn bitxor(self, _rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T> BitXor<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: BitXor<Output = T::Native>, 

type Output = ChunkedArray<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXor<ChunkedArray<BooleanType>> for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T> ChunkAgg<<T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T::Native as Simd>::Simd: Add<Output = <T::Native as Simd>::Simd> + Sum<T::Native> + SimdOrd<T::Native>, 

fn sum(&self) -> Option<T::Native>

Aggregate the sum of the ChunkedArray. Returns None if the array is empty or only contains null values.

fn min(&self) -> Option<T::Native>

fn max(&self) -> Option<T::Native>

Returns the maximum value in the array, according to the natural order. Returns None if the array is empty or only contains null values.

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

Returns the mean value in the array. Returns None if the array is empty or only contains null values.

fn median(&self) -> Option<f64>

Returns the mean value in the array. Returns None if the array is empty or only contains null values.

fn quantile(
    &self,
    quantile: f64,
    interpol: QuantileInterpolOptions
) -> Result<Option<T::Native>>

Aggregate a given quantile of the ChunkedArray. Returns None if the array is empty or only contains null values.

impl<T> ChunkAggSeries for ChunkedArray<T> where
    T: PolarsNumericType,
    <T::Native as Simd>::Simd: Add<Output = <T::Native as Simd>::Simd> + Sum<T::Native> + SimdOrd<T::Native>,
    ChunkedArray<T>: IntoSeries, 

fn sum_as_series(&self) -> Series

Get the sum of the ChunkedArray as a new Series of length 1.

fn max_as_series(&self) -> Series

Get the max of the ChunkedArray as a new Series of length 1.

fn min_as_series(&self) -> Series

Get the min of the ChunkedArray as a new Series of length 1.

fn mean_as_series(&self) -> Series

Get the mean of the ChunkedArray as a new Series of length 1.

fn median_as_series(&self) -> Series

Get the median of the ChunkedArray as a new Series of length 1.

fn prod_as_series(&self) -> Series

Get the product of the ChunkedArray as a new Series of length 1.

fn quantile_as_series(
    &self,
    quantile: f64,
    interpol: QuantileInterpolOptions
) -> Result<Series>

Get the quantile of the ChunkedArray as a new Series of length 1.

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

unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>

Get a single value. Beware this is slow. If you need to use this slightly performant, cast Categorical to UInt32

fn get_any_value(&self, index: usize) -> AnyValue<'_>

Get a single value. Beware this is slow.

impl<'a, T> ChunkApply<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

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

Apply a closure elementwise and cast to a Numeric ChunkedArray. This is fastest when the null check branching is more expensive than the closure application.

fn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(Option<T::Native>) -> S::Native,
    S: PolarsNumericType, 

Apply a closure on optional values and cast to Numeric ChunkedArray without null values.

fn apply<F>(&'a self, f: F) -> Self where
    F: Fn(T::Native) -> T::Native + Copy, 

Apply a closure elementwise. This is fastest when the null check branching is more expensive than the closure application. Often it is.

fn try_apply<F>(&'a self, f: F) -> Result<Self> where
    F: Fn(T::Native) -> Result<T::Native> + Copy, 

fn apply_on_opt<F>(&'a self, f: F) -> Self where
    F: Fn(Option<T::Native>) -> Option<T::Native> + Copy, 

Apply a closure elementwise including null values.

fn apply_with_idx<F>(&'a self, f: F) -> Self where
    F: Fn((usize, T::Native)) -> T::Native + Copy, 

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_with_idx_on_opt<F>(&'a self, f: F) -> Self where
    F: Fn((usize, Option<T::Native>)) -> Option<T::Native> + Copy, 

Apply a closure elementwise. The closure gets the index of the element as first argument.

fn apply_to_slice<F, V>(&'a self, f: F, slice: &mut [V]) where
    F: Fn(Option<T::Native>, &V) -> V, 

Apply a closure elementwise and write results to a mutable slice.

impl<T> ChunkApplyKernel<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn apply_kernel<F>(&self, f: F) -> Self where
    F: Fn(&PrimitiveArray<T::Native>) -> ArrayRef, 

Apply kernel and return result as a new ChunkedArray.

fn apply_kernel_cast<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(&PrimitiveArray<T::Native>) -> ArrayRef,
    S: PolarsDataType, 

Apply a kernel that outputs an array of different type.

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

fn cast(&self, data_type: &DataType) -> Result<Series>

Cast a [ChunkedArray] to [DataType]

impl ChunkCompare<&'_ ChunkedArray<BooleanType>> for BooleanChunked

fn eq_missing(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than or equal comparison

impl ChunkCompare<&'_ ChunkedArray<ListType>> for ListChunked

fn eq_missing(&self, rhs: &ListChunked) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: &ListChunked) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &ListChunked) -> BooleanChunked

Check for inequality.

fn gt(&self, _rhs: &ListChunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, _rhs: &ListChunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, _rhs: &ListChunked) -> BooleanChunked

Less than or equal comparison

impl<T> ChunkCompare<&'_ ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn eq_missing(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &ChunkedArray<T>) -> BooleanChunked

Less than or equal comparison

impl ChunkCompare<&'_ ChunkedArray<Utf8Type>> for Utf8Chunked

fn eq_missing(&self, rhs: &Utf8Chunked) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: &Utf8Chunked) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &Utf8Chunked) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &Utf8Chunked) -> BooleanChunked

Less than or equal comparison

impl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T> where
    T: PolarsNumericType,
    Rhs: ToPrimitive, 

fn eq_missing(&self, rhs: Rhs) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: Rhs) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: Rhs) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: Rhs) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: Rhs) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: Rhs) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: Rhs) -> BooleanChunked

Less than or equal comparison

impl<T> ChunkCumAgg<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: FromIterator<Option<T::Native>>, 

fn cummax(&self, reverse: bool) -> ChunkedArray<T>

Get an array with the cumulative max computed at every element

fn cummin(&self, reverse: bool) -> ChunkedArray<T>

Get an array with the cumulative min computed at every element

fn cumsum(&self, reverse: bool) -> ChunkedArray<T>

Get an array with the cumulative sum computed at every element

fn cumprod(&self, reverse: bool) -> ChunkedArray<T>

Get an array with the cumulative product computed at every element

impl<T> ChunkExpandAtIndex<T> for ChunkedArray<T> where
    ChunkedArray<T>: ChunkFull<T::Native> + TakeRandom<Item = T::Native>,
    T: PolarsNumericType, 

fn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<T>

Create a new ChunkedArray filled with values at that index.

impl<T> ChunkFillNull for ChunkedArray<T> where
    T: PolarsNumericType,
    <T::Native as Simd>::Simd: Add<Output = <T::Native as Simd>::Simd> + Sum<T::Native> + SimdOrd<T::Native>, 

fn fill_null(&self, strategy: FillNullStrategy) -> Result<Self>

Replace None values with one of the following strategies:

impl<T> ChunkFillNullValue<<T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn fill_null_with_values(&self, value: T::Native) -> Result<Self>

Replace None values with a give value T.

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

fn filter(&self, filter: &BooleanChunked) -> Result<ChunkedArray<T>>

Filter values in the ChunkedArray with a boolean mask.

impl<T> ChunkFull<<T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn full(name: &str, value: T::Native, length: usize) -> Self

Create a ChunkedArray with a single value.

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

fn full_null(name: &str, length: usize) -> Self

impl<T> ChunkLen for ChunkedArray<T>

fn len(&self) -> usize

Combined length of all the chunks.

fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

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

fn rechunk(&self) -> Self

Aggregate to contiguous memory.

fn slice(&self, offset: i64, length: usize) -> Self

Slice the array. The chunks are reallocated the underlying data slices are zero copy.

fn limit(&self, num_elements: usize) -> Self where
    Self: Sized, 

Take a view of top n elements

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

Get the head of the ChunkedArray

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

Get the tail of the ChunkedArray

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

fn peak_max(&self) -> BooleanChunked

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> BooleanChunked

Get a boolean mask of the local minimum peaks.

impl<T> ChunkReverse<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: ChunkOps, 

fn reverse(&self) -> ChunkedArray<T>

Return a reversed version of this array.

impl<T> ChunkRollApply for ChunkedArray<T> where
    T: PolarsNumericType,
    Self: IntoSeries, 

fn rolling_apply(
    &self,
    f: &dyn Fn(&Series) -> Series,
    options: RollingOptions
) -> Result<Series>

Apply a rolling custom function. This is pretty slow because of dynamic dispatch.

impl<'a, T> ChunkSet<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    value: Option<T::Native>
) -> Result<Self>

Set the values at indexes idx to some optional value Option<T>.

fn set_at_idx_with<I: IntoIterator<Item = usize>, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>, 

Set the values at indexes idx by applying a closure to these values.

fn set(
    &'a self,
    mask: &BooleanChunked,
    value: Option<T::Native>
) -> Result<Self>

Set the values where the mask evaluates to true to some optional value Option<T>.

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    F: Fn(Option<T::Native>) -> Option<T::Native>, 

Set the values where the mask evaluates to true by applying a closure to these values.

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

fn shift(&self, periods: i64) -> ChunkedArray<T>

impl<T> ChunkShiftFill<T, Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<T::Native>
) -> ChunkedArray<T>

Shift the values by a given period and fill the parts that will be empty due to this operation with fill_value.

impl<T> ChunkSort<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Default + PlIsNan, 

fn argsort_multiple(
    &self,
    other: &[Series],
    reverse: &[bool]
) -> Result<UInt32Chunked>

Panics

This function is very opinionated. We assume that all numeric Series are of the same type, if not it will panic

fn sort_with(&self, options: SortOptions) -> ChunkedArray<T>

fn sort(&self, reverse: bool) -> ChunkedArray<T>

Returned a sorted ChunkedArray.

fn argsort(&self, reverse: bool) -> UInt32Chunked

Retrieve the indexes needed to sort this array.

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

unsafe fn take_unchecked<I, INulls>(
    &self,
    indices: TakeIdx<'_, I, INulls>
) -> Self where
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls, 

Take values from ChunkedArray by index.

fn take<I, INulls>(&self, indices: TakeIdx<'_, I, INulls>) -> Result<Self> where
    Self: Sized,
    I: TakeIterator,
    INulls: TakeIteratorNulls, 

Take values from ChunkedArray by index. Note that the iterator will be cloned, so prefer an iterator that takes the owned memory by reference.

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

fn take_every(&self, n: usize) -> ChunkedArray<T>

Traverse and collect every nth element in a new array.

impl<T> ChunkUnique<T> for ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: Hash + Eq,
    ChunkedArray<T>: ChunkOps + IntoSeries, 

fn unique(&self) -> Result<Self>

Get unique values of a ChunkedArray

fn arg_unique(&self) -> Result<UInt32Chunked>

Get first index of the unique values in a ChunkedArray. This Vec is sorted.

fn is_unique(&self) -> Result<BooleanChunked>

Get a mask of all the unique values.

fn is_duplicated(&self) -> Result<BooleanChunked>

Get a mask of all the duplicated values.

fn value_counts(&self) -> Result<DataFrame>

Count the unique values.

fn n_unique(&self) -> Result<usize>

Number of unique values in the ChunkedArray

fn mode(&self) -> Result<Self>

This is supported on crate feature mode only.

The most occurring value(s). Can return multiple Values

impl<T> ChunkVar<f64> for ChunkedArray<T> where
    T: PolarsIntegerType,
    <T::Native as Simd>::Simd: Add<Output = <T::Native as Simd>::Simd> + Sum<T::Native> + SimdOrd<T::Native>, 

fn var(&self) -> Option<f64>

Compute the variance of this ChunkedArray/Series.

fn std(&self) -> Option<f64>

Compute the standard deviation of this ChunkedArray/Series.

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

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &ChunkedArray<T>
) -> Result<ChunkedArray<T>>

Create a new ChunkedArray with values from self where the mask evaluates true and values from other where the mask evaluates false

impl<T> Clone for ChunkedArray<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<BooleanType>

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

Formats the value using the given formatter.

impl<T> Default for ChunkedArray<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Div<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsNumericType, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, N> Div<N> for &ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, N> Div<N> for ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Drop for ChunkedArray<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: PolarsNumericType> From<&'_ [<T as PolarsNumericType>::Native]> for ChunkedArray<T>

fn from(slice: &[T::Native]) -> Self

Performs the conversion.

impl From<&'_ ChunkedArray<CategoricalType>> for DictionaryArray<u32>

fn from(ca: &CategoricalChunked) -> Self

Performs the conversion.

impl From<&'_ ChunkedArray<CategoricalType>> for DictionaryArray<i64>

fn from(ca: &CategoricalChunked) -> Self

Performs the conversion.

impl<'a> From<&'a ChunkedArray<BooleanType>> for Vec<Option<bool>>

fn from(ca: &'a BooleanChunked) -> Self

Performs the conversion.

impl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<T::Native>> where
    T: PolarsNumericType, 

fn from(ca: &'a ChunkedArray<T>) -> Self

Performs the conversion.

impl<'a> From<&'a ChunkedArray<UInt32Type>> for TakeIdx<'a, Dummy<usize>, Dummy<Option<usize>>>

Conversion from UInt32Chunked to Unchecked TakeIdx

fn from(ca: &'a UInt32Chunked) -> Self

Performs the conversion.

impl<'a> From<&'a ChunkedArray<Utf8Type>> for Vec<Option<&'a str>>

From trait

fn from(ca: &'a Utf8Chunked) -> Self

Performs the conversion.

impl<T: PolarsNumericType> From<(&'_ str, PrimitiveArray<<T as PolarsNumericType>::Native>)> for ChunkedArray<T>

fn from(tpl: (&str, PrimitiveArray<T::Native>)) -> Self

Performs the conversion.

impl From<ChunkedArray<BooleanType>> for Vec<Option<bool>>

fn from(ca: BooleanChunked) -> Self

Performs the conversion.

impl From<ChunkedArray<Int32Type>> for DateChunked

fn from(ca: Int32Chunked) -> Self

Performs the conversion.

impl From<ChunkedArray<Int64Type>> for TimeChunked

fn from(ca: Int64Chunked) -> Self

Performs the conversion.

impl<T> From<ChunkedArray<T>> for Series where
    T: PolarsDataType,
    ChunkedArray<T>: IntoSeries, 

fn from(ca: ChunkedArray<T>) -> Self

Performs the conversion.

impl From<ChunkedArray<UInt32Type>> for CategoricalChunked

fn from(ca: UInt32Chunked) -> Self

Performs the conversion.

impl From<ChunkedArray<Utf8Type>> for Vec<Option<String>>

fn from(ca: Utf8Chunked) -> Self

Performs the conversion.

impl<T: PolarsNumericType> From<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T>

fn from(a: PrimitiveArray<T::Native>) -> Self

Performs the conversion.

impl<T> FromIterator<(Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn from_iter<I: IntoIterator<Item = (Vec<T::Native>, Option<Bitmap>)>>(
    iter: I
) -> Self

Creates a value from an iterator.

impl<T> FromIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

FromIterator trait

fn from_iter<I: IntoIterator<Item = Option<T::Native>>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<bool>> for ChunkedArray<BooleanType>

fn from_iter<I: IntoIterator<Item = Option<bool>>>(iter: I) -> Self

Creates a value from an iterator.

impl<T> FromIteratorReversed<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn from_trusted_len_iter_rev<I: TrustedLen<Item = Option<T::Native>>>(
    iter: I
) -> Self

impl<T> FromParallelIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn from_par_iter<I: IntoParallelIterator<Item = Option<T::Native>>>(
    iter: I
) -> Self

Creates an instance of the collection from the parallel iterator par_iter.

impl<T> FromTrustedLenIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn from_iter_trusted_length<I: IntoIterator<Item = Option<T::Native>>>(
    iter: I
) -> Self

impl FromTrustedLenIterator<Option<bool>> for ChunkedArray<BooleanType>

fn from_iter_trusted_length<I: IntoIterator<Item = Option<bool>>>(
    iter: I
) -> Self where
    I::IntoIter: TrustedLen, 

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

fn interpolate(&self) -> Self

impl<T> IntoGroupTuples for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: NumCast, 

fn group_tuples(&self, multithreaded: bool) -> GroupTuples

Create the tuples need for a groupby operation. * The first value in the tuple is the first index of the group. * The second value in the tuple is are the indexes of the groups including the first value.

impl<'a, T> IntoIterator for &'a ChunkedArray<T> where
    T: PolarsNumericType, 

type Item = Option<T::Native>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = Self::Item> + 'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<T> where
    T: PolarsNumericType, 

type Item = T::Native

type TakeRandom = TakeRandBranch3<NumTakeRandomCont<'a, T::Native>, NumTakeRandomSingleChunk<'a, T::Native>, NumTakeRandomChunked<'a, T::Native>>

fn take_rand(&self) -> Self::TakeRandom

Create a type that implements TakeRandom.

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

fn is_first(&self) -> Result<BooleanChunked>

This is supported on crate feature is_first only.

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

fn is_in(&self, other: &Series) -> Result<BooleanChunked>

This is supported on crate feature is_in only.

Check if elements of this array are in the right Series, or List values of the right Series.

impl<T> Mul<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsNumericType, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, N> Mul<N> for &ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, N> Mul<N> for ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: AsRef<[Option<String>]>> NamedFrom<T, [Option<String>]> for ChunkedArray<Utf8Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<bool>]>> NamedFrom<T, [Option<bool>]> for ChunkedArray<BooleanType>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f32>]>> NamedFrom<T, [Option<f32>]> for ChunkedArray<Float32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f64>]>> NamedFrom<T, [Option<f64>]> for ChunkedArray<Float64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i32>]>> NamedFrom<T, [Option<i32>]> for ChunkedArray<Int32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i64>]>> NamedFrom<T, [Option<i64>]> for ChunkedArray<Int64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u32>]>> NamedFrom<T, [Option<u32>]> for ChunkedArray<UInt32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u64>]>> NamedFrom<T, [Option<u64>]> for ChunkedArray<UInt64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[String]>> NamedFrom<T, [String]> for ChunkedArray<Utf8Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[bool]>> NamedFrom<T, [bool]> for ChunkedArray<BooleanType>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f32]>> NamedFrom<T, [f32]> for ChunkedArray<Float32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f64]>> NamedFrom<T, [f64]> for ChunkedArray<Float64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i32]>> NamedFrom<T, [i32]> for ChunkedArray<Int32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i64]>> NamedFrom<T, [i64]> for ChunkedArray<Int64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u32]>> NamedFrom<T, [u32]> for ChunkedArray<UInt32Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u64]>> NamedFrom<T, [u64]> for ChunkedArray<UInt64Type>

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T> NewChunkedArray<T, <T as PolarsNumericType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType, 

fn new_from_iter(
    name: &str,
    it: impl Iterator<Item = T::Native>
) -> ChunkedArray<T>

Create a new ChunkedArray from an iterator.

fn new_from_slice(name: &str, v: &[T::Native]) -> Self

fn new_from_opt_slice(name: &str, opt_v: &[Option<T::Native>]) -> Self

fn new_from_opt_iter(
    name: &str,
    it: impl Iterator<Item = Option<T::Native>>
) -> ChunkedArray<T>

Create a new ChunkedArray from an iterator.

impl<T> NumOpsDispatch for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: IntoSeries, 

fn subtract(&self, rhs: &Series) -> Result<Series>

fn add_to(&self, rhs: &Series) -> Result<Series>

fn multiply(&self, rhs: &Series) -> Result<Series>

fn divide(&self, rhs: &Series) -> Result<Series>

fn remainder(&self, rhs: &Series) -> Result<Series>

impl<T> NumOpsDispatchChecked for ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: CheckedDiv<Output = T::Native> + Zero + One,
    ChunkedArray<T>: IntoSeries, 

fn checked_div(&self, rhs: &Series) -> Result<Series>

Checked integer division. Computes self / rhs, returning None if rhs == 0 or the division results in overflow.

fn checked_div_num<T: ToPrimitive>(&self, _rhs: T) -> Result<Series>

impl<T> Pow for ChunkedArray<T> where
    T: PolarsNumericType,
    ChunkedArray<T>: ChunkCast, 

fn pow_f32(&self, exp: f32) -> Float32Chunked

fn pow_f64(&self, exp: f64) -> Float64Chunked

impl<T> Rem<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsNumericType, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T, N> Rem<N> for &ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: N) -> Self::Output

Performs the % operation.

impl<T, N> Rem<N> for ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: N) -> Self::Output

Performs the % operation.

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

fn repeat_by(&self, by: &UInt32Chunked) -> ListChunked

This is supported on crate feature repeat_by only.

Repeat the values n times, where n is determined by the values in by.

impl<T> StrConcat for ChunkedArray<T> where
    T: PolarsNumericType,
    T::Native: Display, 

fn str_concat(&self, delimiter: &str) -> Utf8Chunked

This is supported on crate feature concat_str only.

Concat the values into a string array.

impl<T> Sub<&'_ ChunkedArray<T>> for &ChunkedArray<T> where
    T: PolarsNumericType, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, N> Sub<N> for &ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, N> Sub<N> for ChunkedArray<T> where
    T: PolarsNumericType,
    N: Num + ToPrimitive, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Item = T::Native

fn get(&self, index: usize) -> Option<Self::Item>

Get a nullable value by index.

unsafe fn get_unchecked(&self, index: usize) -> Option<Self::Item>

Get a value by index and ignore the null bit.

impl<'a, T> TakeRandom for &'a ChunkedArray<T> where
    T: PolarsNumericType, 

type Item = T::Native

fn get(&self, index: usize) -> Option<Self::Item>

Get a nullable value by index.

unsafe fn get_unchecked(&self, index: usize) -> Option<Self::Item>

Get a value by index and ignore the null bit.

impl<T> ToDummies<T> for ChunkedArray<T> where
    T: PolarsIntegerType + Sync,
    T::Native: Hash + Eq,
    ChunkedArray<T>: ChunkOps + ChunkCompare<T::Native> + ChunkUnique<T>, 

fn to_dummies(&self) -> Result<DataFrame>

impl<T> VarAggSeries for ChunkedArray<T> where
    T: PolarsIntegerType,
    <T::Native as Simd>::Simd: Add<Output = <T::Native as Simd>::Simd> + Sum<T::Native> + SimdOrd<T::Native>, 

fn var_as_series(&self) -> Series

Get the variance of the ChunkedArray as a new Series of length 1.

fn std_as_series(&self) -> Series

Get the standard deviation of the ChunkedArray as a new Series of length 1.

impl<T> VecHash for ChunkedArray<T> where
    T: PolarsIntegerType,
    T::Native: Hash + CallHasher, 

fn vec_hash(&self, random_state: RandomState) -> Vec<u64>

Compute the hash for all values in the array.

fn vec_hash_combine(&self, random_state: RandomState, hashes: &mut [u64])

impl<T> ZipOuterJoinColumn for ChunkedArray<T> where
    T: PolarsIntegerType,
    ChunkedArray<T>: IntoSeries, 

fn zip_outer_join_column(
    &self,
    right_column: &Series,
    opt_join_tuples: &[(Option<u32>, Option<u32>)]
) -> Series