Struct polars::chunked_array::ChunkedArray

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

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.cast::<Float64Type>()
        .unwrap()
        .apply(|v| v.cos())
}

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> ChunkedArray<T> where
    T: PolarsNumericType, 

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

pub fn downcast_chunks(
    &self
) -> Chunks<'_, PrimitiveArray<<T as PolarsPrimitiveType>::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 ChunkedArray<BooleanType>

pub fn arg_true(&self) -> ChunkedArray<UInt32Type>

impl ChunkedArray<BooleanType>

pub fn all_true(&self) -> bool

Check if all values are true

impl ChunkedArray<BooleanType>

pub fn all_false(&self) -> bool

Check if all values are false

impl<T> ChunkedArray<T> where
    T: PolarsFloatType,
    <T as PolarsPrimitiveType>::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>

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 self
) -> impl Iterator<Item = &'a str> + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen + 'a

impl ChunkedArray<ListType>

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

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

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<ArrayBase<ViewRepr<&<T as PolarsPrimitiveType>::Native>, Dim<[usize; 1]>>, PolarsError>

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<ArrayBase<OwnedRepr<<N as PolarsPrimitiveType>::Native>, Dim<[usize; 2]>>, PolarsError> where
    N: PolarsNumericType, 

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

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

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

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

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

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 + 'static)>

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

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

pub fn sample_n(
    &self,
    n: usize,
    with_replacement: bool
) -> Result<ChunkedArray<T>, PolarsError>

Sample n datapoints from this ChunkedArray.

pub fn sample_frac(
    &self,
    frac: f64,
    with_replacement: bool
) -> Result<ChunkedArray<T>, PolarsError>

Sample a fraction between 0.0-1.0 of this ChunkedArray.

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

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

Create ChunkedArray with samples from a Normal distribution.

pub fn rand_standard_normal(name: &str, length: usize) -> ChunkedArray<T>

Create ChunkedArray with samples from a Standard Normal distribution.

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

Create ChunkedArray with samples from a Uniform distribution.

impl ChunkedArray<BooleanType>

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

Create ChunkedArray with samples from a Bernoulli distribution.

impl ChunkedArray<Utf8Type>

pub fn json_path_match(
    &self,
    json_path: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

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

impl ChunkedArray<Utf8Type>

pub fn str_lengths(&self) -> ChunkedArray<UInt32Type>

Get the length of the string values.

pub fn contains(
    &self,
    pat: &str
) -> Result<ChunkedArray<BooleanType>, PolarsError>

Check if strings contain a regex pattern

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

Replace the leftmost (sub)string by a regex pattern

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

Replace all (sub)strings by a regex pattern

pub fn to_lowercase(&self) -> ChunkedArray<Utf8Type>

Modify the strings to their lowercase equivalent

pub fn to_uppercase(&self) -> ChunkedArray<Utf8Type>

Modify the strings to their uppercase equivalent

pub fn concat(&self, other: &ChunkedArray<Utf8Type>) -> ChunkedArray<Utf8Type>

Concat with the values from a second Utf8Chunked

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

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 ChunkedArray<Utf8Type>

pub fn as_date32(
    &self,
    fmt: Option<&str>
) -> Result<ChunkedArray<Date32Type>, PolarsError>

pub fn as_date64(
    &self,
    fmt: Option<&str>
) -> Result<ChunkedArray<Date64Type>, PolarsError>

impl ChunkedArray<Date64Type>

pub fn year(&self) -> ChunkedArray<Int32Type>

Extract month from underlying NaiveDateTime representation. Returns the year number in the calendar date.

pub fn month(&self) -> ChunkedArray<UInt32Type>

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

The return value ranges from 1 to 12.

pub fn weekday(&self) -> ChunkedArray<UInt32Type>

Extract weekday from underlying NaiveDateTime representation. Returns the weekday number where monday = 0 and sunday = 6

pub fn week(&self) -> ChunkedArray<UInt32Type>

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

pub fn day(&self) -> ChunkedArray<UInt32Type>

Extract day from underlying NaiveDateTime representation. Returns the day of month starting from 1.

The return value ranges from 1 to 31. (The last day of month differs by months.)

pub fn hour(&self) -> ChunkedArray<UInt32Type>

Extract hour from underlying NaiveDateTime representation. Returns the hour number from 0 to 23.

pub fn minute(&self) -> ChunkedArray<UInt32Type>

Extract minute from underlying NaiveDateTime representation. Returns the minute number from 0 to 59.

pub fn second(&self) -> ChunkedArray<UInt32Type>

Extract second from underlying NaiveDateTime representation. Returns the second number from 0 to 59.

pub fn nanosecond(&self) -> ChunkedArray<UInt32Type>

Extract second from underlying NaiveDateTime representation. Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

pub fn ordinal(&self) -> ChunkedArray<UInt32Type>

Returns the day of year starting from 1.

The return value ranges from 1 to 366. (The last day of year differs by years.)

pub fn strftime(&self, fmt: &str) -> ChunkedArray<Utf8Type>

Format Date64 with a fmt rule. See chrono strftime/strptime.

impl ChunkedArray<Date32Type>

pub fn year(&self) -> ChunkedArray<Int32Type>

Extract month from underlying NaiveDate representation. Returns the year number in the calendar date.

pub fn month(&self) -> ChunkedArray<UInt32Type>

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

The return value ranges from 1 to 12.

pub fn weekday(&self) -> ChunkedArray<UInt32Type>

Extract weekday from underlying NaiveDate representation. Returns the weekday number where monday = 0 and sunday = 6

pub fn week(&self) -> ChunkedArray<UInt32Type>

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

pub fn day(&self) -> ChunkedArray<UInt32Type>

Extract day from underlying NaiveDate representation. Returns the day of month starting from 1.

The return value ranges from 1 to 31. (The last day of month differs by months.)

pub fn ordinal(&self) -> ChunkedArray<UInt32Type>

Returns the day of year starting from 1.

The return value ranges from 1 to 366. (The last day of year differs by years.)

pub fn strftime(&self, fmt: &str) -> ChunkedArray<Utf8Type>

Format Date32 with a fmt rule. See chrono strftime/strptime.

impl ChunkedArray<ListType>

pub fn amortized_iter(
    &self
) -> AmortizedListIter<'_, impl Iterator<Item = Option<Box<dyn Array + 'static, Global>>>>

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) -> ChunkedArray<ListType> where
    F: Fn(UnsafeSeries<'a>) -> Series + Copy, 

Apply a closure F elementwise.

pub fn try_apply_amortized<'a, F>(
    &'a self,
    f: F
) -> Result<ChunkedArray<ListType>, PolarsError> where
    F: Fn(UnsafeSeries<'a>) -> Result<Series, PolarsError> + Copy, 

impl<T> ChunkedArray<T>

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

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

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

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

pub fn null_bits(&self) -> impl Iterator<Item = (usize, &Option<Bitmap>)>

Get the buffer of bits representing 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>, PolarsError>

Series to ChunkedArray

pub fn len(&self) -> usize

Combined length of all the chunks.

pub fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

pub fn chunk_id(
    &self
) -> Map<Iter<'_, Arc<dyn Array + 'static>>, fn(&Arc<dyn Array + 'static>) -> usize>

Unique id representing the number of chunks

pub fn chunks(&self) -> &Vec<Arc<dyn Array + 'static>, Global>

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 limit(&self, num_elements: usize) -> ChunkedArray<T>

Take a view of top n elements

pub fn append_array(
    &mut self,
    other: Arc<dyn Array + 'static>
) -> Result<(), PolarsError>

Append arrow array in place.

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

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

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

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

When offset is negative it will be counted from the end of the array. This method will never error, and will slice the best match when offset, or length is out of bounds

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

Get a mask of the null values.

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

Get a mask of the valid values.

pub fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Get the head of the ChunkedArray

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

Get the tail of the ChunkedArray

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

Append in place.

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<Arc<dyn Array + 'static>, Global>
) -> ChunkedArray<T>

Create a new ChunkedArray from existing chunks.

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

pub fn new_from_aligned_vec(
    name: &str,
    v: MutableBuffer<<T as PolarsPrimitiveType>::Native>
) -> ChunkedArray<T>

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

pub fn new_from_owned_with_null_bitmap(
    name: &str,
    values: MutableBuffer<<T as PolarsPrimitiveType>::Native>,
    buffer: Option<Bitmap>
) -> ChunkedArray<T>

Nullify values in slice with an existing null bitmap

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

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

Contiguous slice

pub fn data_views(
    &self
) -> impl Iterator<Item = &[<T as PolarsPrimitiveType>::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 as PolarsPrimitiveType>::Native> + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

pub fn map<B, F>(
    &self,
    f: F
) -> Result<Map<Copied<Iter<'_, <T as PolarsPrimitiveType>::Native>>, F>, PolarsError> where
    F: Fn(<T as PolarsPrimitiveType>::Native) -> B, 

If cont_slice is successful a closure is mapped over the elements.

Example

use polars_core::prelude::*;
fn multiply(ca: &UInt32Chunked) -> Result<Series> {
    let mapped = ca.map(|v| v * 2)?;
    Ok(mapped.collect())
}

pub fn map_null_checks<B, F>(
    &'a self,
    f: F
) -> Map<Box<dyn PolarsIterator<Item = Option<<T as PolarsPrimitiveType>::Native>> + 'a, Global>, F> where
    F: Fn(Option<<T as PolarsPrimitiveType>::Native>) -> B, 

If cont_slice fails we can fallback on an iterator with null checks and map a closure over the elements.

Example

use polars_core::prelude::*;
use itertools::Itertools;
fn multiply(ca: &UInt32Chunked) -> Series {
    let mapped_result = ca.map(|v| v * 2);

    if let Ok(mapped) = mapped_result {
        mapped.collect()
    } else {
        ca
        .map_null_checks(|opt_v| opt_v.map(|v |v * 2)).collect()
    }
}

pub fn fold<F, B>(&self, init: B, f: F) -> Result<B, PolarsError> where
    F: Fn(B, <T as PolarsPrimitiveType>::Native) -> B, 

If cont_slice is successful a closure can be applied as aggregation

Example

use polars_core::prelude::*;
fn compute_sum(ca: &UInt32Chunked) -> Result<u32> {
    ca.fold(0, |acc, value| acc + value)
}

pub fn fold_null_checks<F, B>(&self, init: B, f: F) -> B where
    F: Fn(B, Option<<T as PolarsPrimitiveType>::Native>) -> B, 

If cont_slice fails we can fallback on an iterator with null checks and a closure for aggregation

Example

use polars_core::prelude::*;
fn compute_sum(ca: &UInt32Chunked) -> u32 {
    match ca.fold(0, |acc, value| acc + value) {
        // faster sum without null checks was successful
        Ok(sum) => sum,
        // Null values or multiple chunks in ChunkedArray, we need to do more bounds checking
        Err(_) => ca.fold_null_checks(0, |acc, opt_value| {
            match opt_value {
                Some(v) => acc + v,
                None => acc
            }
        })
    }
}

impl ChunkedArray<ListType>

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the list.

impl ChunkedArray<Date32Type>

pub fn round(&self, rule: SampleRule) -> ChunkedArray<Date32Type>

impl ChunkedArray<Date64Type>

pub fn round(&self, rule: SampleRule) -> ChunkedArray<Date64Type>

impl<T> ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    ChunkedArray<T>: IntoSeries,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

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>(&self, lhs: N) -> ChunkedArray<T> where
    N: Num + NumCast, 

Apply lhs - self

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

Apply lhs / self

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

Apply lhs % self

Trait Implementations

impl<'_, T> Add<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: &'_ ChunkedArray<T>
) -> <&'_ ChunkedArray<T> as Add<&'_ ChunkedArray<T>>>::Output

Performs the + operation.

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

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: &'_ ChunkedArray<Utf8Type>
) -> <&'_ ChunkedArray<Utf8Type> as Add<&'_ ChunkedArray<Utf8Type>>>::Output

Performs the + operation.

impl<'_, '_> Add<&'_ str> for &'_ ChunkedArray<Utf8Type>

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: &str
) -> <&'_ ChunkedArray<Utf8Type> as Add<&'_ str>>::Output

Performs the + operation.

impl<T> Add<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Add<ChunkedArray<T>>>::Output

Performs the + operation.

impl Add<ChunkedArray<Utf8Type>> for ChunkedArray<Utf8Type>

type Output = ChunkedArray<Utf8Type>

The resulting type after applying the + operator.

pub fn add(
    self,
    rhs: ChunkedArray<Utf8Type>
) -> <ChunkedArray<Utf8Type> as Add<ChunkedArray<Utf8Type>>>::Output

Performs the + operation.

impl<T, N> Add<N> for ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: N) -> <ChunkedArray<T> as Add<N>>::Output

Performs the + operation.

impl<'_, T, N> Add<N> for &'_ ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

pub fn add(self, rhs: N) -> <&'_ ChunkedArray<T> as Add<N>>::Output

Performs the + operation.

impl AggList for ChunkedArray<ListType>

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

impl<T> AggList for ChunkedArray<ObjectType<T>>

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

impl AggList for ChunkedArray<BooleanType>

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

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

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

impl AggList for ChunkedArray<Utf8Type>

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

impl<T> ArgAgg for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>, 

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

Get the index of the minimal value

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

Get the index of the maximal value

impl ArgAgg for ChunkedArray<CategoricalType>

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 ArgAgg for ChunkedArray<ListType>

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<T> ArgAgg for ChunkedArray<ObjectType<T>>

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 ArgAgg for ChunkedArray<BooleanType>

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 ArgAgg for ChunkedArray<Utf8Type>

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 AsNaiveDate for ChunkedArray<Date32Type>

pub fn as_naive_date_iter(
    &'a self
) -> Box<dyn Iterator<Item = Option<NaiveDate>> + 'a, Global>

impl AsNaiveDateTime for ChunkedArray<Date64Type>

pub fn as_naive_datetime_iter(
    &'a self
) -> Box<dyn Iterator<Item = Option<NaiveDateTime>> + 'a, Global>

impl AsNaiveDateTime for ChunkedArray<Date32Type>

pub fn as_naive_datetime_iter(
    &'a self
) -> Box<dyn Iterator<Item = Option<NaiveDateTime>> + 'a, Global>

impl AsNaiveTime for ChunkedArray<Time64NanosecondType>

pub fn as_naive_time(&self) -> Vec<Option<NaiveTime>, Global>

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

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

Performs the conversion.

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

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

Performs the conversion.

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

pub fn bitand(
    self,
    rhs: &'_ ChunkedArray<BooleanType>
) -> <&'_ ChunkedArray<BooleanType> as BitAnd<&'_ ChunkedArray<BooleanType>>>::Output

Performs the & operation.

impl BitAnd<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

pub fn bitand(
    self,
    rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitAnd<ChunkedArray<BooleanType>>>::Output

Performs the & operation.

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.

pub fn bitor(
    self,
    rhs: &'_ ChunkedArray<BooleanType>
) -> <&'_ ChunkedArray<BooleanType> as BitOr<&'_ ChunkedArray<BooleanType>>>::Output

Performs the | operation.

impl BitOr<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.

pub fn bitor(
    self,
    rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitOr<ChunkedArray<BooleanType>>>::Output

Performs the | operation.

impl<T> ChunkAgg<<T as PolarsPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NativeType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Sum<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: SimdOrd<<T as PolarsPrimitiveType>::Native>,
    <<<T as PolarsPrimitiveType>::Native as Simd>::Simd as Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>>::Output == <<T as PolarsPrimitiveType>::Native as Simd>::Simd, 

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

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

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

pub fn max(&self) -> Option<<T as PolarsPrimitiveType>::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.

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

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

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

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

pub fn quantile(
    &self,
    quantile: f64
) -> Result<Option<<T as PolarsPrimitiveType>::Native>, PolarsError>

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

impl ChunkAgg<Series> for ChunkedArray<ListType>

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

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

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

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

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) -> Result<Option<T>, PolarsError>

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

impl ChunkAgg<String> for ChunkedArray<Utf8Type>

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

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

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

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

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) -> Result<Option<T>, PolarsError>

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

impl ChunkAgg<u32> for ChunkedArray<BooleanType>

Booleans are casted to 1 or 0.

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

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

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

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

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) -> Result<Option<T>, PolarsError>

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

impl ChunkAggSeries for ChunkedArray<BooleanType>

pub fn sum_as_series(&self) -> Series

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

pub fn max_as_series(&self) -> Series

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

pub fn min_as_series(&self) -> Series

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

pub fn mean_as_series(&self) -> Series

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

pub fn median_as_series(&self) -> Series

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

pub fn quantile_as_series(&self, _quantile: f64) -> Result<Series, PolarsError>

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

impl ChunkAggSeries for ChunkedArray<CategoricalType>

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 quantile_as_series(&self, _quantile: f64) -> Result<Series, PolarsError>

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

impl<T> ChunkAggSeries for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NativeType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Sum<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: SimdOrd<<T as PolarsPrimitiveType>::Native>,
    ChunkedArray<T>: IntoSeries,
    <<<T as PolarsPrimitiveType>::Native as Simd>::Simd as Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>>::Output == <<T as PolarsPrimitiveType>::Native as Simd>::Simd, 

pub fn sum_as_series(&self) -> Series

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

pub fn max_as_series(&self) -> Series

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

pub fn min_as_series(&self) -> Series

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

pub fn mean_as_series(&self) -> Series

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

pub fn median_as_series(&self) -> Series

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

pub fn quantile_as_series(&self, quantile: f64) -> Result<Series, PolarsError>

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

impl ChunkAggSeries for ChunkedArray<Utf8Type>

pub fn sum_as_series(&self) -> Series

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

pub fn max_as_series(&self) -> Series

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

pub fn min_as_series(&self) -> Series

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

pub fn mean_as_series(&self) -> Series

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

pub fn median_as_series(&self) -> Series

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

pub fn quantile_as_series(&self, _quantile: f64) -> Result<Series, PolarsError>

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

impl ChunkAggSeries for ChunkedArray<ListType>

pub fn sum_as_series(&self) -> Series

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

pub fn max_as_series(&self) -> Series

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

pub fn min_as_series(&self) -> Series

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

pub fn mean_as_series(&self) -> Series

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

pub fn median_as_series(&self) -> Series

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

pub fn quantile_as_series(&self, _quantile: f64) -> Result<Series, PolarsError>

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

impl<T> ChunkAggSeries for ChunkedArray<ObjectType<T>>

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 quantile_as_series(&self, _quantile: f64) -> Result<Series, PolarsError>

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

impl ChunkAnyValue for ChunkedArray<ListType>

pub 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

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

Get a single value. Beware this is slow.

impl ChunkAnyValue for ChunkedArray<BooleanType>

pub 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

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

Get a single value. Beware this is slow.

impl ChunkAnyValue for ChunkedArray<Utf8Type>

pub 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

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

Get a single value. Beware this is slow.

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

pub 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

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

Get a single value. Beware this is slow.

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

pub 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

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

Get a single value. Beware this is slow.

impl ChunkAnyValue for ChunkedArray<CategoricalType>

pub 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

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

Get a single value. Beware this is slow.

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

pub fn apply_cast_numeric<F, S>(&'a self, _f: F) -> ChunkedArray<S> where
    F: Fn(&'a T) -> <S as PolarsPrimitiveType>::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.

pub fn branch_apply_cast_numeric_no_null<F, S>(
    &'a self,
    _f: F
) -> ChunkedArray<S> where
    F: Fn(Option<&'a T>) -> <S as PolarsPrimitiveType>::Native + Copy,
    S: PolarsNumericType, 

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

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

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

pub fn try_apply<F>(
    &'a self,
    _f: F
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError> where
    F: Fn(&'a T) -> Result<T, PolarsError> + Copy, 

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

Apply a closure elementwise including null values.

pub fn apply_with_idx<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>> where
    F: Fn((usize, &'a T)) -> T + Copy, 

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

pub fn apply_with_idx_on_opt<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>> where
    F: Fn((usize, Option<&'a T>)) -> Option<T> + Copy, 

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

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

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

impl<'a> ChunkApply<'a, &'a str, Cow<'a, str>> for ChunkedArray<Utf8Type>

pub fn apply_cast_numeric<F, S>(&'a self, f: F) -> ChunkedArray<S> where
    F: Fn(&'a str) -> <S as PolarsPrimitiveType>::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.

pub fn branch_apply_cast_numeric_no_null<F, S>(
    &'a self,
    f: F
) -> ChunkedArray<S> where
    F: Fn(Option<&'a str>) -> <S as PolarsPrimitiveType>::Native + Copy,
    S: PolarsNumericType, 

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

pub fn apply<F>(&'a self, f: F) -> ChunkedArray<Utf8Type> where
    F: Fn(&'a str) -> Cow<'a, str> + Copy, 

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

pub fn try_apply<F>(
    &'a self,
    f: F
) -> Result<ChunkedArray<Utf8Type>, PolarsError> where
    F: Fn(&'a str) -> Result<Cow<'a, str>, PolarsError> + Copy, 

pub fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<Utf8Type> where
    F: Fn(Option<&'a str>) -> Option<Cow<'a, str>> + Copy, 

Apply a closure elementwise including null values.

pub fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<Utf8Type> where
    F: Fn((usize, &'a str)) -> Cow<'a, str> + Copy, 

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

pub fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<Utf8Type> where
    F: Fn((usize, Option<&'a str>)) -> Option<Cow<'a, str>> + Copy, 

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

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

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

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

pub fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(<T as PolarsPrimitiveType>::Native) -> <S as PolarsPrimitiveType>::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.

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

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

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

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

pub fn try_apply<F>(&'a self, f: F) -> Result<ChunkedArray<T>, PolarsError> where
    F: Fn(<T as PolarsPrimitiveType>::Native) -> Result<<T as PolarsPrimitiveType>::Native, PolarsError> + Copy, 

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

Apply a closure elementwise including null values.

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

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

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

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

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

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

impl<'a> ChunkApply<'a, Series, Series> for ChunkedArray<ListType>

pub fn apply<F>(&'a self, f: F) -> ChunkedArray<ListType> where
    F: Fn(Series) -> Series + Copy, 

Apply a closure F elementwise.

pub fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<ListType> where
    F: Fn((usize, Series)) -> Series + Copy, 

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

pub fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType> where
    F: Fn((usize, Option<Series>)) -> Option<Series> + Copy, 

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

pub fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(Series) -> <S as PolarsPrimitiveType>::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.

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

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

pub fn try_apply<F>(
    &'a self,
    f: F
) -> Result<ChunkedArray<ListType>, PolarsError> where
    F: Fn(Series) -> Result<Series, PolarsError> + Copy, 

pub fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType> where
    F: Fn(Option<Series>) -> Option<Series> + Copy, 

Apply a closure elementwise including null values.

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

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

impl<'a> ChunkApply<'a, bool, bool> for ChunkedArray<BooleanType>

pub fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(bool) -> <S as PolarsPrimitiveType>::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.

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

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

pub fn apply<F>(&self, f: F) -> ChunkedArray<BooleanType> where
    F: Fn(bool) -> bool + Copy, 

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

pub fn try_apply<F>(
    &self,
    f: F
) -> Result<ChunkedArray<BooleanType>, PolarsError> where
    F: Fn(bool) -> Result<bool, PolarsError> + Copy, 

pub fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType> where
    F: Fn(Option<bool>) -> Option<bool> + Copy, 

Apply a closure elementwise including null values.

pub fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<BooleanType> where
    F: Fn((usize, bool)) -> bool + Copy, 

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

pub fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType> where
    F: Fn((usize, Option<bool>)) -> Option<bool> + Copy, 

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

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

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

impl ChunkApplyKernel<BooleanArray> for ChunkedArray<BooleanType>

pub fn apply_kernel<F>(&self, f: F) -> ChunkedArray<BooleanType> where
    F: Fn(&BooleanArray) -> Arc<dyn Array + 'static>, 

Apply kernel and return result as a new ChunkedArray.

pub fn apply_kernel_cast<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(&BooleanArray) -> Arc<dyn Array + 'static>,
    S: PolarsDataType, 

Apply a kernel that outputs an array of different type.

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

pub fn apply_kernel<F>(&self, f: F) -> ChunkedArray<T> where
    F: Fn(&PrimitiveArray<<T as PolarsPrimitiveType>::Native>) -> Arc<dyn Array + 'static>, 

Apply kernel and return result as a new ChunkedArray.

pub fn apply_kernel_cast<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(&PrimitiveArray<<T as PolarsPrimitiveType>::Native>) -> Arc<dyn Array + 'static>,
    S: PolarsDataType, 

Apply a kernel that outputs an array of different type.

impl ChunkApplyKernel<Utf8Array<i64>> for ChunkedArray<Utf8Type>

pub fn apply_kernel<F>(&self, f: F) -> ChunkedArray<Utf8Type> where
    F: Fn(&Utf8Array<i64>) -> Arc<dyn Array + 'static>, 

Apply kernel and return result as a new ChunkedArray.

pub fn apply_kernel_cast<F, S>(&self, f: F) -> ChunkedArray<S> where
    F: Fn(&Utf8Array<i64>) -> Arc<dyn Array + 'static>,
    S: PolarsDataType, 

Apply a kernel that outputs an array of different type.

impl<T> ChunkCast for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast, 

pub fn cast<N>(&self) -> Result<ChunkedArray<N>, PolarsError> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

pub fn cast_with_dtype(
    &self,
    data_type: &DataType
) -> Result<Series, PolarsError>

impl ChunkCast for ChunkedArray<ListType>

We cannot cast anything to or from List/LargeList So this implementation casts the inner type

pub fn cast<N>(&self) -> Result<ChunkedArray<N>, PolarsError> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

pub fn cast_with_dtype(
    &self,
    data_type: &DataType
) -> Result<Series, PolarsError>

impl ChunkCast for ChunkedArray<BooleanType>

pub fn cast<N>(&self) -> Result<ChunkedArray<N>, PolarsError> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

pub fn cast_with_dtype(
    &self,
    data_type: &DataType
) -> Result<Series, PolarsError>

impl ChunkCast for ChunkedArray<Utf8Type>

pub fn cast<N>(&self) -> Result<ChunkedArray<N>, PolarsError> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

pub fn cast_with_dtype(
    &self,
    data_type: &DataType
) -> Result<Series, PolarsError>

impl ChunkCast for ChunkedArray<CategoricalType>

pub fn cast<N>(&self) -> Result<ChunkedArray<N>, PolarsError> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

pub fn cast_with_dtype(
    &self,
    data_type: &DataType
) -> Result<Series, PolarsError>

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

pub fn eq_missing(
    &self,
    rhs: &ChunkedArray<BooleanType>
) -> ChunkedArray<BooleanType>

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>

Check for inequality.

pub fn gt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>

Greater than comparison.

pub fn gt_eq(
    &self,
    rhs: &ChunkedArray<BooleanType>
) -> ChunkedArray<BooleanType>

Greater than or equal comparison.

pub fn lt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>

Less than comparison.

pub fn lt_eq(
    &self,
    rhs: &ChunkedArray<BooleanType>
) -> ChunkedArray<BooleanType>

Less than or equal comparison

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

pub fn eq_missing(
    &self,
    rhs: &ChunkedArray<ListType>
) -> ChunkedArray<BooleanType>

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Check for inequality.

pub fn gt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Greater than comparison.

pub fn gt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Greater than or equal comparison.

pub fn lt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Less than comparison.

pub fn lt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>

Less than or equal comparison

impl<'_, T> ChunkCompare<&'_ ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumComp,
    <T as PolarsPrimitiveType>::Native: Simd8, 

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

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

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

pub fn eq_missing(
    &self,
    rhs: &ChunkedArray<Utf8Type>
) -> ChunkedArray<BooleanType>

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Check for inequality.

pub fn gt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Greater than comparison.

pub fn gt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Greater than or equal comparison.

pub fn lt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Less than comparison.

pub fn lt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>

Less than or equal comparison

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

pub fn eq_missing(&self, rhs: &str) -> ChunkedArray<BooleanType>

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &str) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: &str) -> ChunkedArray<BooleanType>

Check for inequality.

pub fn gt(&self, rhs: &str) -> ChunkedArray<BooleanType>

Greater than comparison.

pub fn gt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>

Greater than or equal comparison.

pub fn lt(&self, rhs: &str) -> ChunkedArray<BooleanType>

Less than comparison.

pub fn lt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>

Less than or equal comparison

impl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T> where
    T: PolarsNumericType,
    Rhs: NumComp + ToPrimitive,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: NumComp,
    <T as PolarsPrimitiveType>::Native: Simd8, 

pub fn eq_missing(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Check for equality.

pub fn neq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Check for inequality.

pub fn gt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Greater than comparison.

pub fn gt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Greater than or equal comparison.

pub fn lt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Less than comparison.

pub fn lt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>

Less than or equal comparison

impl ChunkCumAgg<BooleanType> for ChunkedArray<BooleanType>

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

impl ChunkCumAgg<CategoricalType> for ChunkedArray<CategoricalType>

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

impl ChunkCumAgg<ListType> for ChunkedArray<ListType>

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

impl<T> ChunkCumAgg<ObjectType<T>> for ChunkedArray<ObjectType<T>>

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

impl<T> ChunkCumAgg<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Bounded,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: AddAssign<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    ChunkedArray<T>: FromIterator<Option<<T as PolarsPrimitiveType>::Native>>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

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

Get an array with the cumulative max computed at every element

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

Get an array with the cumulative min computed at every element

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

Get an array with the cumulative sum computed at every element

impl ChunkCumAgg<Utf8Type> for ChunkedArray<Utf8Type>

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

impl ChunkExpandAtIndex<BooleanType> for ChunkedArray<BooleanType>

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExpandAtIndex<CategoricalType> for ChunkedArray<CategoricalType>

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExpandAtIndex<ListType> for ChunkedArray<ListType>

pub fn expand_at_index(
    &self,
    _index: usize,
    _length: usize
) -> ChunkedArray<ListType>

Create a new ChunkedArray filled with values at that index.

impl<T> ChunkExpandAtIndex<ObjectType<T>> for ChunkedArray<ObjectType<T>>

pub fn expand_at_index(
    &self,
    _index: usize,
    _length: usize
) -> ChunkedArray<ObjectType<T>>

Create a new ChunkedArray filled with values at that index.

impl<T> ChunkExpandAtIndex<T> for ChunkedArray<T> where
    T: PolarsPrimitiveType,
    ChunkedArray<T>: ChunkFull<<T as PolarsPrimitiveType>::Native>,
    ChunkedArray<T>: TakeRandom,
    <ChunkedArray<T> as TakeRandom>::Item == <T as PolarsPrimitiveType>::Native, 

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExpandAtIndex<Utf8Type> for ChunkedArray<Utf8Type>

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExplode for ChunkedArray<Utf8Type>

pub fn explode_and_offsets(&self) -> Result<(Series, Buffer<i64>), PolarsError>

fn explode(&self) -> Result<Series, PolarsError>

impl ChunkExplode for ChunkedArray<ListType>

pub fn explode_and_offsets(&self) -> Result<(Series, Buffer<i64>), PolarsError>

fn explode(&self) -> Result<Series, PolarsError>

impl ChunkFillNull for ChunkedArray<ListType>

pub fn fill_null(
    &self,
    _strategy: FillNullStrategy
) -> Result<ChunkedArray<ListType>, PolarsError>

Replace None values with one of the following strategies:

impl<T> ChunkFillNull for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Bounded,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Sum<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: SimdOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: NativeType,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<<T as PolarsPrimitiveType>::Native as Simd>::Simd as Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>>::Output == <<T as PolarsPrimitiveType>::Native as Simd>::Simd, 

pub fn fill_null(
    &self,
    strategy: FillNullStrategy
) -> Result<ChunkedArray<T>, PolarsError>

Replace None values with one of the following strategies:

impl ChunkFillNull for ChunkedArray<BooleanType>

pub fn fill_null(
    &self,
    strategy: FillNullStrategy
) -> Result<ChunkedArray<BooleanType>, PolarsError>

Replace None values with one of the following strategies:

impl ChunkFillNull for ChunkedArray<Utf8Type>

pub fn fill_null(
    &self,
    strategy: FillNullStrategy
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

Replace None values with one of the following strategies:

impl ChunkFillNull for ChunkedArray<CategoricalType>

pub fn fill_null(
    &self,
    _strategy: FillNullStrategy
) -> Result<ChunkedArray<CategoricalType>, PolarsError>

Replace None values with one of the following strategies:

impl<T> ChunkFillNull for ChunkedArray<ObjectType<T>>

pub fn fill_null(
    &self,
    _strategy: FillNullStrategy
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>

Replace None values with one of the following strategies:

impl<'_> ChunkFillNullValue<&'_ Series> for ChunkedArray<ListType>

pub fn fill_null_with_values(
    &self,
    _value: &Series
) -> Result<ChunkedArray<ListType>, PolarsError>

Replace None values with a give value T.

impl<'_> ChunkFillNullValue<&'_ str> for ChunkedArray<Utf8Type>

pub fn fill_null_with_values(
    &self,
    value: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

Replace None values with a give value T.

impl<T> ChunkFillNullValue<<T as PolarsPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

pub fn fill_null_with_values(
    &self,
    value: <T as PolarsPrimitiveType>::Native
) -> Result<ChunkedArray<T>, PolarsError>

Replace None values with a give value T.

impl<T> ChunkFillNullValue<ObjectType<T>> for ChunkedArray<ObjectType<T>>

pub fn fill_null_with_values(
    &self,
    _value: ObjectType<T>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>

Replace None values with a give value T.

impl ChunkFillNullValue<bool> for ChunkedArray<BooleanType>

pub fn fill_null_with_values(
    &self,
    value: bool
) -> Result<ChunkedArray<BooleanType>, PolarsError>

Replace None values with a give value T.

impl ChunkFilter<BooleanType> for ChunkedArray<BooleanType>

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFilter<CategoricalType> for ChunkedArray<CategoricalType>

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<CategoricalType>, PolarsError> where
    ChunkedArray<CategoricalType>: Sized, 

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFilter<ListType> for ChunkedArray<ListType>

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ListType>, PolarsError>

Filter values in the ChunkedArray with a boolean mask.

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

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError> where
    ChunkedArray<ObjectType<T>>: Sized, 

Filter values in the ChunkedArray with a boolean mask.

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

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<T>, PolarsError>

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFilter<Utf8Type> for ChunkedArray<Utf8Type>

pub fn filter(
    &self,
    filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

Filter values in the ChunkedArray with a boolean mask.

impl<'_> ChunkFull<&'_ Series> for ChunkedArray<ListType>

pub fn full(name: &str, value: &Series, length: usize) -> ChunkedArray<ListType>

Create a ChunkedArray with a single value.

impl<'a> ChunkFull<&'a str> for ChunkedArray<Utf8Type>

pub fn full(name: &str, value: &'a str, length: usize) -> ChunkedArray<Utf8Type>

Create a ChunkedArray with a single value.

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

pub fn full(
    name: &str,
    value: <T as PolarsPrimitiveType>::Native,
    length: usize
) -> ChunkedArray<T> where
    <T as PolarsPrimitiveType>::Native: Copy, 

Create a ChunkedArray with a single value.

impl ChunkFull<bool> for ChunkedArray<BooleanType>

pub fn full(name: &str, value: bool, length: usize) -> ChunkedArray<BooleanType>

Create a ChunkedArray with a single value.

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

pub fn full_null(name: &str, length: usize) -> ChunkedArray<ObjectType<T>>

impl ChunkFullNull for ChunkedArray<BooleanType>

pub fn full_null(name: &str, length: usize) -> ChunkedArray<BooleanType>

impl ChunkFullNull for ChunkedArray<Utf8Type>

pub fn full_null(name: &str, length: usize) -> ChunkedArray<Utf8Type>

impl ChunkFullNull for ChunkedArray<ListType>

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

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

pub fn full_null(name: &str, length: usize) -> ChunkedArray<T>

impl ChunkOps for ChunkedArray<BooleanType>

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

Aggregate to contiguous memory.

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

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

Aggregate to contiguous memory.

impl ChunkOps for ChunkedArray<Utf8Type>

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

Aggregate to contiguous memory.

impl ChunkOps for ChunkedArray<CategoricalType>

pub fn rechunk(&self) -> ChunkedArray<CategoricalType> where
    ChunkedArray<CategoricalType>: Sized, 

Aggregate to contiguous memory.

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

pub fn rechunk(&self) -> ChunkedArray<ObjectType<T>> where
    ChunkedArray<ObjectType<T>>: Sized, 

Aggregate to contiguous memory.

impl ChunkOps for ChunkedArray<ListType>

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

Aggregate to contiguous memory.

impl ChunkPeaks for ChunkedArray<CategoricalType>

fn peak_max(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local minimum peaks.

impl ChunkPeaks for ChunkedArray<ListType>

fn peak_max(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local minimum peaks.

impl ChunkPeaks for ChunkedArray<BooleanType>

fn peak_max(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local minimum peaks.

impl<T> ChunkPeaks for ChunkedArray<ObjectType<T>> where
    T: 'static + Debug + Clone + Send + Sync + Default, 

fn peak_max(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local minimum peaks.

impl ChunkPeaks for ChunkedArray<Utf8Type>

fn peak_max(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local maximum peaks.

fn peak_min(&self) -> ChunkedArray<BooleanType>

Get a boolean mask of the local minimum peaks.

impl<T> ChunkPeaks for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumComp,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd8, 

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

Get a boolean mask of the local maximum peaks.

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

Get a boolean mask of the local minimum peaks.

impl ChunkReverse<BooleanType> for ChunkedArray<BooleanType>

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

Return a reversed version of this array.

impl ChunkReverse<CategoricalType> for ChunkedArray<CategoricalType>

pub fn reverse(&self) -> ChunkedArray<CategoricalType>

Return a reversed version of this array.

impl ChunkReverse<ListType> for ChunkedArray<ListType>

pub fn reverse(&self) -> ChunkedArray<ListType>

Return a reversed version of this array.

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

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

Return a reversed version of this array.

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

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

Return a reversed version of this array.

impl ChunkReverse<Utf8Type> for ChunkedArray<Utf8Type>

pub fn reverse(&self) -> ChunkedArray<Utf8Type>

Return a reversed version of this array.

impl<T> ChunkRollApply for ChunkedArray<ObjectType<T>>

fn rolling_apply(
    &self,
    _window_size: usize,
    _f: &dyn Fn(&Series)
) -> Result<Self, PolarsError>

impl ChunkRollApply for ChunkedArray<BooleanType>

fn rolling_apply(
    &self,
    _window_size: usize,
    _f: &dyn Fn(&Series)
) -> Result<Self, PolarsError>

impl ChunkRollApply for ChunkedArray<Utf8Type>

fn rolling_apply(
    &self,
    _window_size: usize,
    _f: &dyn Fn(&Series)
) -> Result<Self, PolarsError>

impl ChunkRollApply for ChunkedArray<ListType>

fn rolling_apply(
    &self,
    _window_size: usize,
    _f: &dyn Fn(&Series)
) -> Result<Self, PolarsError>

impl ChunkRollApply for ChunkedArray<CategoricalType>

fn rolling_apply(
    &self,
    _window_size: usize,
    _f: &dyn Fn(&Series)
) -> Result<Self, PolarsError>

impl<T> ChunkRollApply for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Zero,
    ChunkedArray<T>: IntoSeries, 

pub fn rolling_apply(
    &self,
    window_size: usize,
    f: &dyn Fn(&Series)
) -> Result<ChunkedArray<T>, PolarsError>

impl<'a> ChunkSet<'a, &'a str, String> for ChunkedArray<Utf8Type>

pub fn set_at_idx<I>(
    &'a self,
    idx: I,
    opt_value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError> where
    I: IntoIterator<Item = usize>,
    ChunkedArray<Utf8Type>: Sized, 

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

pub fn set_at_idx_with<I, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<ChunkedArray<Utf8Type>, PolarsError> where
    F: Fn(Option<&'a str>) -> Option<String>,
    I: IntoIterator<Item = usize>,
    ChunkedArray<Utf8Type>: Sized, 

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

pub fn set(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError> where
    ChunkedArray<Utf8Type>: Sized, 

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

pub fn set_with<F>(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    f: F
) -> Result<ChunkedArray<Utf8Type>, PolarsError> where
    F: Fn(Option<&'a str>) -> Option<String>,
    ChunkedArray<Utf8Type>: Sized, 

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

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

pub fn set_at_idx<I>(
    &'a self,
    idx: I,
    value: Option<<T as PolarsPrimitiveType>::Native>
) -> Result<ChunkedArray<T>, PolarsError> where
    I: IntoIterator<Item = usize>, 

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

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

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

pub fn set(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    value: Option<<T as PolarsPrimitiveType>::Native>
) -> Result<ChunkedArray<T>, PolarsError>

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

pub fn set_with<F>(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    f: F
) -> Result<ChunkedArray<T>, PolarsError> where
    F: Fn(Option<<T as PolarsPrimitiveType>::Native>) -> Option<<T as PolarsPrimitiveType>::Native>, 

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

impl<'a> ChunkSet<'a, bool, bool> for ChunkedArray<BooleanType>

pub fn set_at_idx<I>(
    &'a self,
    idx: I,
    value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError> where
    I: IntoIterator<Item = usize>, 

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

pub fn set_at_idx_with<I, F>(
    &'a self,
    idx: I,
    f: F
) -> Result<ChunkedArray<BooleanType>, PolarsError> where
    F: Fn(Option<bool>) -> Option<bool>,
    I: IntoIterator<Item = usize>, 

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

pub fn set(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

pub fn set_with<F>(
    &'a self,
    mask: &ChunkedArray<BooleanType>,
    f: F
) -> Result<ChunkedArray<BooleanType>, PolarsError> where
    F: Fn(Option<bool>) -> Option<bool>, 

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

impl ChunkShift<BooleanType> for ChunkedArray<BooleanType>

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

impl ChunkShift<CategoricalType> for ChunkedArray<CategoricalType>

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

impl ChunkShift<ListType> for ChunkedArray<ListType>

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

impl<T> ChunkShift<ObjectType<T>> for ChunkedArray<ObjectType<T>>

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

impl<T> ChunkShift<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Copy, 

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

impl ChunkShift<Utf8Type> for ChunkedArray<Utf8Type>

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

impl ChunkShiftFill<BooleanType, Option<bool>> for ChunkedArray<BooleanType>

pub fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<bool>
) -> ChunkedArray<BooleanType>

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

impl<'_> ChunkShiftFill<ListType, Option<&'_ Series>> for ChunkedArray<ListType>

pub fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<&Series>
) -> ChunkedArray<ListType>

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

impl<T> ChunkShiftFill<ObjectType<T>, Option<ObjectType<T>>> for ChunkedArray<ObjectType<T>>

pub fn shift_and_fill(
    &self,
    _periods: i64,
    _fill_value: Option<ObjectType<T>>
) -> ChunkedArray<ObjectType<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> ChunkShiftFill<T, Option<<T as PolarsPrimitiveType>::Native>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Copy, 

pub fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<<T as PolarsPrimitiveType>::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<'_> ChunkShiftFill<Utf8Type, Option<&'_ str>> for ChunkedArray<Utf8Type>

pub fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<&str>
) -> ChunkedArray<Utf8Type>

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

impl ChunkSort<BooleanType> for ChunkedArray<BooleanType>

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

fn argsort_multiple(
    &self,
    _other: &[Series],
    _reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Retrieve the indexes need to sort this and the other arrays.

impl ChunkSort<CategoricalType> for ChunkedArray<CategoricalType>

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

fn argsort_multiple(
    &self,
    _other: &[Series],
    _reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Retrieve the indexes need to sort this and the other arrays.

impl ChunkSort<ListType> for ChunkedArray<ListType>

pub fn sort(&self, _reverse: bool) -> ChunkedArray<ListType>

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, _reverse: bool)

Sort this array in place.

pub fn argsort(&self, _reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

fn argsort_multiple(
    &self,
    _other: &[Series],
    _reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Retrieve the indexes need to sort this and the other arrays.

impl<T> ChunkSort<ObjectType<T>> for ChunkedArray<ObjectType<T>>

pub fn sort(&self, _reverse: bool) -> ChunkedArray<ObjectType<T>>

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, _reverse: bool)

Sort this array in place.

pub fn argsort(&self, _reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

fn argsort_multiple(
    &self,
    _other: &[Series],
    _reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Retrieve the indexes need to sort this and the other arrays.

impl<T> ChunkSort<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>, 

pub fn argsort_multiple(
    &self,
    other: &[Series],
    reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Panics

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

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl ChunkSort<Utf8Type> for ChunkedArray<Utf8Type>

pub fn argsort_multiple(
    &self,
    other: &[Series],
    reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Panics

This function is very opinionated. On the implementation of ChunkedArray<T> for numeric types, we assume that all numeric Series are of the same type.

In this case we assume that all numeric Series are f64 types. The caller needs to uphold this contract. If not, it will panic.

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

Returned a sorted ChunkedArray.

pub fn sort_in_place(&mut self, reverse: bool)

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl ChunkTake for ChunkedArray<CategoricalType>

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

Take values from ChunkedArray by index.

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

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 ChunkTake for ChunkedArray<BooleanType>

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

Take values from ChunkedArray by index.

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

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> ChunkTake for ChunkedArray<T> where
    T: PolarsNumericType, 

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

Take values from ChunkedArray by index.

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

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> ChunkTake for ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

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

Take values from ChunkedArray by index.

pub fn take<I, INulls>(
    &self,
    indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError> where
    I: TakeIterator,
    INulls: TakeIteratorNulls,
    ChunkedArray<ObjectType<T>>: Sized, 

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 ChunkTake for ChunkedArray<Utf8Type>

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

Take values from ChunkedArray by index.

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

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 ChunkTake for ChunkedArray<ListType>

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

Take values from ChunkedArray by index.

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

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 ChunkTakeEvery<BooleanType> for ChunkedArray<BooleanType>

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

Traverse and collect every nth element in a new array.

impl ChunkTakeEvery<CategoricalType> for ChunkedArray<CategoricalType>

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

Traverse and collect every nth element in a new array.

impl ChunkTakeEvery<ListType> for ChunkedArray<ListType>

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

Traverse and collect every nth element in a new array.

impl<T> ChunkTakeEvery<ObjectType<T>> for ChunkedArray<ObjectType<T>>

pub fn take_every(&self, _n: usize) -> ChunkedArray<ObjectType<T>>

Traverse and collect every nth element in a new array.

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

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

Traverse and collect every nth element in a new array.

impl ChunkTakeEvery<Utf8Type> for ChunkedArray<Utf8Type>

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

Traverse and collect every nth element in a new array.

impl ChunkUnique<BooleanType> for ChunkedArray<BooleanType>

pub fn unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

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

Number of unique values in the ChunkedArray

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

Count the unique values.

fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

impl ChunkUnique<CategoricalType> for ChunkedArray<CategoricalType>

pub fn unique(&self) -> Result<ChunkedArray<CategoricalType>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame, PolarsError>

Count the unique values.

pub fn n_unique(&self) -> Result<usize, PolarsError>

Number of unique values in the ChunkedArray

pub fn mode(&self) -> Result<ChunkedArray<CategoricalType>, PolarsError>

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

impl ChunkUnique<Float32Type> for ChunkedArray<Float32Type>

pub fn unique(&self) -> Result<ChunkedArray<Float32Type>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame, PolarsError>

Count the unique values.

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

Number of unique values in the ChunkedArray

fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

impl ChunkUnique<Float64Type> for ChunkedArray<Float64Type>

pub fn unique(&self) -> Result<ChunkedArray<Float64Type>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame, PolarsError>

Count the unique values.

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

Number of unique values in the ChunkedArray

fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

impl ChunkUnique<ListType> for ChunkedArray<ListType>

pub fn unique(&self) -> Result<ChunkedArray<ListType>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

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

Number of unique values in the ChunkedArray

fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

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

Count the unique values.

fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

impl<T> ChunkUnique<ObjectType<T>> for ChunkedArray<ObjectType<T>>

pub fn unique(&self) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

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

Number of unique values in the ChunkedArray

fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

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

Count the unique values.

fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

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

pub fn unique(&self) -> Result<ChunkedArray<T>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame, PolarsError>

Count the unique values.

pub fn n_unique(&self) -> Result<usize, PolarsError>

Number of unique values in the ChunkedArray

pub fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>

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

impl ChunkUnique<Utf8Type> for ChunkedArray<Utf8Type>

pub fn unique(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

pub fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the unique values.

pub fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

Get a mask of all the duplicated values.

pub fn value_counts(&self) -> Result<DataFrame, PolarsError>

Count the unique values.

pub fn n_unique(&self) -> Result<usize, PolarsError>

Number of unique values in the ChunkedArray

pub fn mode(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>

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

impl<T> ChunkVar<Series> for ChunkedArray<ObjectType<T>>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<Series> for ChunkedArray<ListType>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<String> for ChunkedArray<Utf8Type>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<bool> for ChunkedArray<BooleanType>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<f32> for ChunkedArray<Float32Type>

pub fn var(&self) -> Option<f32>

Compute the variance of this ChunkedArray/Series.

pub fn std(&self) -> Option<f32>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<f64> for ChunkedArray<Float64Type>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkVar<f64> for ChunkedArray<T> where
    T: PolarsIntegerType,
    <T as PolarsPrimitiveType>::Native: NativeType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Sum<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: SimdOrd<<T as PolarsPrimitiveType>::Native>,
    <<<T as PolarsPrimitiveType>::Native as Simd>::Simd as Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>>::Output == <<T as PolarsPrimitiveType>::Native as Simd>::Simd, 

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<u32> for ChunkedArray<CategoricalType>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkWindow for ChunkedArray<ObjectType<T>>

fn rolling_sum(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

fn rolling_mean(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

fn rolling_min(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

fn rolling_max(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl ChunkWindow for ChunkedArray<CategoricalType>

fn rolling_sum(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

fn rolling_mean(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

fn rolling_min(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

fn rolling_max(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl ChunkWindow for ChunkedArray<BooleanType>

fn rolling_sum(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

fn rolling_mean(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

fn rolling_min(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

fn rolling_max(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl ChunkWindow for ChunkedArray<Utf8Type>

fn rolling_sum(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

fn rolling_mean(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

fn rolling_min(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

fn rolling_max(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl<T> ChunkWindow for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Bounded,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Copy,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

pub fn rolling_sum(
    &self,
    window_size: u32,
    weight: Option<&[f64]>,
    ignore_null: bool,
    min_periods: u32
) -> Result<ChunkedArray<T>, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

pub fn rolling_mean(
    &self,
    window_size: u32,
    weight: Option<&[f64]>,
    ignore_null: bool,
    min_periods: u32
) -> Result<ChunkedArray<T>, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

pub fn rolling_min(
    &self,
    window_size: u32,
    weight: Option<&[f64]>,
    ignore_null: bool,
    min_periods: u32
) -> Result<ChunkedArray<T>, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

pub fn rolling_max(
    &self,
    window_size: u32,
    weight: Option<&[f64]>,
    ignore_null: bool,
    min_periods: u32
) -> Result<ChunkedArray<T>, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl ChunkWindow for ChunkedArray<ListType>

fn rolling_sum(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. the resulting values will be aggregated to their sum.

fn rolling_mean(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their mean.

fn rolling_min(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their min.

fn rolling_max(
    &self,
    _window_size: u32,
    _weight: Option<&[f64]>,
    _ignore_null: bool,
    _min_periods: u32
) -> Result<Self, PolarsError>

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 weight vector. The resulting values will be aggregated to their max.

impl<T> ChunkWindowCustom<<T as PolarsPrimitiveType>::Native> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Bounded,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Copy,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

This is similar to how rolling_min, sum, max, mean is implemented. It takes a window, weights it and applies a fold aggregator

pub fn rolling_custom<F>(
    &self,
    window_size: u32,
    weight: Option<&[f64]>,
    fold_fn: F,
    init_fold: InitFold,
    min_periods: u32
) -> Result<ChunkedArray<T>, PolarsError> where
    F: Fn(Option<<T as PolarsPrimitiveType>::Native>, Option<<T as PolarsPrimitiveType>::Native>) -> Option<<T as PolarsPrimitiveType>::Native> + Copy, 

Apply a rolling aggregation over the values in this array.

impl ChunkZip<BooleanType> for ChunkedArray<BooleanType>

pub fn zip_with(
    &self,
    mask: &ChunkedArray<BooleanType>,
    other: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

impl ChunkZip<CategoricalType> for ChunkedArray<CategoricalType>

pub fn zip_with(
    &self,
    mask: &ChunkedArray<BooleanType>,
    other: &ChunkedArray<CategoricalType>
) -> Result<ChunkedArray<CategoricalType>, PolarsError>

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

impl ChunkZip<ListType> for ChunkedArray<ListType>

pub fn zip_with(
    &self,
    mask: &ChunkedArray<BooleanType>,
    other: &ChunkedArray<ListType>
) -> Result<ChunkedArray<ListType>, PolarsError>

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

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

pub fn zip_with(
    &self,
    mask: &ChunkedArray<BooleanType>,
    other: &ChunkedArray<ObjectType<T>>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>

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

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

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

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

impl ChunkZip<Utf8Type> for ChunkedArray<Utf8Type>

pub fn zip_with(
    &self,
    mask: &ChunkedArray<BooleanType>,
    other: &ChunkedArray<Utf8Type>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

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>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChunkedArray<BooleanType>

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<CategoricalType>

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<Utf8Type>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<ListType>

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

Formats the value using the given formatter.

impl<T> Default for ChunkedArray<T>

pub fn default() -> ChunkedArray<T>

Returns the “default value” for a type.

impl Deref for ChunkedArray<CategoricalType>

type Target = ChunkedArray<UInt32Type>

The resulting type after dereferencing.

pub fn deref(&self) -> &<ChunkedArray<CategoricalType> as Deref>::Target

Dereferences the value.

impl DerefMut for ChunkedArray<CategoricalType>

pub fn deref_mut(
    &mut self
) -> &mut <ChunkedArray<CategoricalType> as Deref>::Target

Mutably dereferences the value.

impl<'_, T> Div<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    rhs: &'_ ChunkedArray<T>
) -> <&'_ ChunkedArray<T> as Div<&'_ ChunkedArray<T>>>::Output

Performs the / operation.

impl<T> Div<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Div<ChunkedArray<T>>>::Output

Performs the / operation.

impl<'_, T, N> Div<N> for &'_ ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

pub fn div(self, rhs: N) -> <&'_ ChunkedArray<T> as Div<N>>::Output

Performs the / operation.

impl<T, N> Div<N> for ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

pub fn div(self, rhs: N) -> <ChunkedArray<T> as Div<N>>::Output

Performs the / operation.

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

Conversion from UInt32Chunked to Unchecked TakeIdx

pub fn from(
    ca: &'a ChunkedArray<UInt32Type>
) -> TakeIdx<'a, Once<usize>, Once<Option<usize>>>

Performs the conversion.

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

pub fn from(ca: ChunkedArray<T>) -> Series

Performs the conversion.

impl From<ChunkedArray<UInt32Type>> for ChunkedArray<CategoricalType>

pub fn from(ca: ChunkedArray<UInt32Type>) -> ChunkedArray<CategoricalType>

Performs the conversion.

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

pub fn from(
    a: PrimitiveArray<<T as PolarsPrimitiveType>::Native>
) -> ChunkedArray<T>

Performs the conversion.

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

pub fn from_iter<I>(iter: I) -> ChunkedArray<T> where
    I: IntoIterator<Item = (MutableBuffer<<T as PolarsPrimitiveType>::Native>, Option<Bitmap>)>, 

Creates a value from an iterator.

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

FromIterator trait

pub fn from_iter<I>(iter: I) -> ChunkedArray<T> where
    I: IntoIterator<Item = Option<<T as PolarsPrimitiveType>::Native>>, 

Creates a value from an iterator.

impl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<Utf8Type> where
    Ptr: AsRef<str>, 

pub fn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoIterator<Item = Option<Ptr>>, 

Creates a value from an iterator.

impl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<ListType> where
    Ptr: Borrow<Series>, 

pub fn from_iter<I>(iter: I) -> ChunkedArray<ListType> where
    I: IntoIterator<Item = Option<Ptr>>, 

Creates a value from an iterator.

impl<T> FromIterator<Option<T>> for ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub fn from_iter<I>(iter: I) -> ChunkedArray<ObjectType<T>> where
    I: IntoIterator<Item = Option<T>>, 

Creates a value from an iterator.

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

pub fn from_iter<I>(iter: I) -> ChunkedArray<BooleanType> where
    I: IntoIterator<Item = Option<bool>>, 

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for ChunkedArray<ListType> where
    Ptr: Borrow<Series>, 

pub fn from_iter<I>(iter: I) -> ChunkedArray<ListType> where
    I: IntoIterator<Item = Ptr>, 

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for ChunkedArray<Utf8Type> where
    Ptr: PolarsAsRef<str>, 

pub fn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoIterator<Item = Ptr>, 

Creates a value from an iterator.

impl FromIterator<bool> for ChunkedArray<BooleanType>

pub fn from_iter<I>(iter: I) -> ChunkedArray<BooleanType> where
    I: IntoIterator<Item = bool>, 

Creates a value from an iterator.

impl FromNaiveDate<Date32Type, NaiveDate> for ChunkedArray<Date32Type>

pub fn new_from_naive_date(
    name: &str,
    v: &[NaiveDate]
) -> ChunkedArray<Date32Type>

pub fn parse_from_str_slice(
    name: &str,
    v: &[&str],
    fmt: &str
) -> ChunkedArray<Date32Type>

impl FromNaiveDateTime<Date64Type, NaiveDateTime> for ChunkedArray<Date64Type>

pub fn new_from_naive_datetime(
    name: &str,
    v: &[NaiveDateTime]
) -> ChunkedArray<Date64Type>

pub fn parse_from_str_slice(
    name: &str,
    v: &[&str],
    fmt: &str
) -> ChunkedArray<Date64Type>

impl FromNaiveTime<Time64NanosecondType, NaiveTime> for ChunkedArray<Time64NanosecondType>

pub fn new_from_naive_time(
    name: &str,
    v: &[NaiveTime]
) -> ChunkedArray<Time64NanosecondType>

pub fn parse_from_str_slice(
    name: &str,
    v: &[&str],
    fmt: &str
) -> ChunkedArray<Time64NanosecondType>

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

pub fn from_par_iter<I>(iter: I) -> ChunkedArray<T> where
    I: IntoParallelIterator<Item = Option<<T as PolarsPrimitiveType>::Native>>, 

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

impl<Ptr> FromParallelIterator<Option<Ptr>> for ChunkedArray<Utf8Type> where
    Ptr: AsRef<str> + Send + Sync, 

pub fn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoParallelIterator<Item = Option<Ptr>>, 

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

impl<Ptr> FromParallelIterator<Ptr> for ChunkedArray<Utf8Type> where
    Ptr: PolarsAsRef<str> + Send + Sync, 

pub fn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoParallelIterator<Item = Ptr>, 

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

impl FromParallelIterator<bool> for ChunkedArray<BooleanType>

pub fn from_par_iter<I>(iter: I) -> ChunkedArray<BooleanType> where
    I: IntoParallelIterator<Item = bool>, 

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

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

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<T> where
    I: IntoIterator<Item = Option<<T as PolarsPrimitiveType>::Native>>, 

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<ListType> where
    Ptr: Borrow<Series>, 

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ListType> where
    I: IntoIterator<Item = Option<Ptr>>, 

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<Utf8Type> where
    Ptr: AsRef<str>, 

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoIterator<Item = Option<Ptr>>, 

impl<T> FromTrustedLenIterator<Option<T>> for ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ObjectType<T>> where
    I: IntoIterator<Item = Option<T>>, 

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

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<BooleanType> where
    I: IntoIterator<Item = Option<bool>>,
    <I as IntoIterator>::IntoIter: TrustedLen, 

impl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<Utf8Type> where
    Ptr: PolarsAsRef<str>, 

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<Utf8Type> where
    I: IntoIterator<Item = Ptr>, 

impl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<ListType> where
    Ptr: Borrow<Series>, 

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ListType> where
    I: IntoIterator<Item = Ptr>, 

impl FromTrustedLenIterator<bool> for ChunkedArray<BooleanType>

pub fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<BooleanType> where
    I: IntoIterator<Item = bool>,
    <I as IntoIterator>::IntoIter: TrustedLen, 

impl<T> Interpolate for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: FromPrimitive,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

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

impl Interpolate for ChunkedArray<CategoricalType>

pub fn interpolate(&self) -> ChunkedArray<CategoricalType>

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

pub fn interpolate(&self) -> ChunkedArray<ObjectType<T>>

impl Interpolate for ChunkedArray<Utf8Type>

pub fn interpolate(&self) -> ChunkedArray<Utf8Type>

impl Interpolate for ChunkedArray<BooleanType>

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

impl Interpolate for ChunkedArray<ListType>

pub fn interpolate(&self) -> ChunkedArray<ListType>

impl IntoGroupTuples for ChunkedArray<BooleanType>

pub fn group_tuples(
    &self,
    multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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 IntoGroupTuples for ChunkedArray<Utf8Type>

pub fn group_tuples(
    &self,
    multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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 IntoGroupTuples for ChunkedArray<ListType>

fn group_tuples(
    &self,
    _multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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 IntoGroupTuples for ChunkedArray<CategoricalType>

pub fn group_tuples(
    &self,
    multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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<T> IntoGroupTuples for ChunkedArray<ObjectType<T>> where
    T: PolarsObject, 

pub fn group_tuples(
    &self,
    _multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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<T> IntoGroupTuples for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast, 

pub fn group_tuples(
    &self,
    multithreaded: bool
) -> Vec<(u32, Vec<u32, Global>), Global>

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> IntoIterator for &'a ChunkedArray<BooleanType>

type Item = Option<bool>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BooleanType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(
    self
) -> <&'a ChunkedArray<BooleanType> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a ChunkedArray<ListType>

type Item = Option<Series>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ListType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'a ChunkedArray<ListType> as IntoIterator>::IntoIter

Creates an iterator from a value.

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

type Item = Option<&'a T>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(
    self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::IntoIter

Creates an iterator from a value.

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

type Item = Option<<T as PolarsPrimitiveType>::Native>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<T> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'a ChunkedArray<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a ChunkedArray<CategoricalType>

type Item = Option<u32>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<CategoricalType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(
    self
) -> <&'a ChunkedArray<CategoricalType> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a> IntoIterator for &'a ChunkedArray<Utf8Type>

type Item = Option<&'a str>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<Utf8Type> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'a ChunkedArray<Utf8Type> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoSeries for ChunkedArray<Utf8Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

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

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<UInt32Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Int8Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<UInt16Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Float32Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Int16Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<BooleanType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Float64Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Int64Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Date32Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<UInt8Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<DurationNanosecondType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Time64NanosecondType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<ListType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<UInt64Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Int32Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<Date64Type>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<DurationMillisecondType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for ChunkedArray<CategoricalType>

pub fn into_series(self) -> Series

fn is_series() -> bool

impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<BooleanType>

type Item = bool

type TakeRandom = TakeRandBranch2<BoolTakeRandomSingleChunk<'a>, BoolTakeRandom<'a>>

pub fn take_rand(
    &self
) -> <&'a ChunkedArray<BooleanType> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<ListType>

type Item = Series

type TakeRandom = TakeRandBranch2<ListTakeRandomSingleChunk<'a>, ListTakeRandom<'a>>

pub fn take_rand(
    &self
) -> <&'a ChunkedArray<ListType> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

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

type Item = <T as PolarsPrimitiveType>::Native

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

pub fn take_rand(
    &self
) -> <&'a ChunkedArray<T> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

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

type Item = &'a T

type TakeRandom = TakeRandBranch2<ObjectTakeRandomSingleChunk<'a, T>, ObjectTakeRandom<'a, T>>

pub fn take_rand(
    &self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<Utf8Type>

type Item = &'a str

type TakeRandom = TakeRandBranch2<Utf8TakeRandomSingleChunk<'a>, Utf8TakeRandom<'a>>

pub fn take_rand(
    &self
) -> <&'a ChunkedArray<Utf8Type> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

impl IsFirst<BooleanType> for ChunkedArray<BooleanType>

fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

impl IsFirst<CategoricalType> for ChunkedArray<CategoricalType>

pub fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

impl IsFirst<ListType> for ChunkedArray<ListType>

fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

impl<T> IsFirst<T> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast, 

pub fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

impl IsFirst<Utf8Type> for ChunkedArray<Utf8Type>

pub fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>

impl<T> IsIn for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Copy, 

pub fn is_in(
    &self,
    other: &Series
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

impl IsIn for ChunkedArray<CategoricalType>

pub fn is_in(
    &self,
    other: &Series
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

impl IsIn for ChunkedArray<BooleanType>

pub fn is_in(
    &self,
    other: &Series
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

impl IsIn for ChunkedArray<Utf8Type>

pub fn is_in(
    &self,
    other: &Series
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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

impl IsIn for ChunkedArray<ListType>

fn is_in(
    &self,
    _other: &Series
) -> Result<ChunkedArray<BooleanType>, PolarsError>

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,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    rhs: &'_ ChunkedArray<T>
) -> <&'_ ChunkedArray<T> as Mul<&'_ ChunkedArray<T>>>::Output

Performs the * operation.

impl<T> Mul<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Mul<ChunkedArray<T>>>::Output

Performs the * operation.

impl<'_, T, N> Mul<N> for &'_ ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: N) -> <&'_ ChunkedArray<T> as Mul<N>>::Output

Performs the * operation.

impl<T, N> Mul<N> for ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

pub fn mul(self, rhs: N) -> <ChunkedArray<T> as Mul<N>>::Output

Performs the * operation.

impl NewChunkedArray<BooleanType, bool> for ChunkedArray<BooleanType>

pub fn new_from_iter(
    name: &str,
    it: impl Iterator<Item = bool>
) -> ChunkedArray<BooleanType>

Create a new ChunkedArray from an iterator.

pub fn new_from_slice(name: &str, v: &[bool]) -> ChunkedArray<BooleanType>

pub fn new_from_opt_slice(
    name: &str,
    opt_v: &[Option<bool>]
) -> ChunkedArray<BooleanType>

pub fn new_from_opt_iter(
    name: &str,
    it: impl Iterator<Item = Option<bool>>
) -> ChunkedArray<BooleanType>

Create a new ChunkedArray from an iterator.

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

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

Create a new ChunkedArray from an iterator.

pub fn new_from_slice(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>

pub fn new_from_opt_slice(
    name: &str,
    opt_v: &[Option<T>]
) -> ChunkedArray<ObjectType<T>>

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

Create a new ChunkedArray from an iterator.

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

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

Create a new ChunkedArray from an iterator.

pub fn new_from_slice(
    name: &str,
    v: &[<T as PolarsPrimitiveType>::Native]
) -> ChunkedArray<T>

pub fn new_from_opt_slice(
    name: &str,
    opt_v: &[Option<<T as PolarsPrimitiveType>::Native>]
) -> ChunkedArray<T>

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

Create a new ChunkedArray from an iterator.

impl<S> NewChunkedArray<Utf8Type, S> for ChunkedArray<Utf8Type> where
    S: AsRef<str>, 

pub fn new_from_iter(
    name: &str,
    it: impl Iterator<Item = S>
) -> ChunkedArray<Utf8Type>

Create a new ChunkedArray from an iterator.

pub fn new_from_slice(name: &str, v: &[S]) -> ChunkedArray<Utf8Type>

pub fn new_from_opt_slice(
    name: &str,
    opt_v: &[Option<S>]
) -> ChunkedArray<Utf8Type>

pub fn new_from_opt_iter(
    name: &str,
    it: impl Iterator<Item = Option<S>>
) -> ChunkedArray<Utf8Type>

Create a new ChunkedArray from an iterator.

impl<'_> Not for &'_ ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ! operator.

pub fn not(self) -> <&'_ ChunkedArray<BooleanType> as Not>::Output

Performs the unary ! operation.

impl Not for ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ! operator.

pub fn not(self) -> <ChunkedArray<BooleanType> as Not>::Output

Performs the unary ! operation.

impl NumOpsDispatch for ChunkedArray<Utf8Type>

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

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

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

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

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

impl NumOpsDispatch for ChunkedArray<ListType>

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

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

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

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

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

impl NumOpsDispatch for ChunkedArray<BooleanType>

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

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

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

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

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

impl NumOpsDispatch for ChunkedArray<CategoricalType>

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

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

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

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

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

impl<T> NumOpsDispatch for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    ChunkedArray<T>: IntoSeries,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

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

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

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<ListType>

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<Float32Type>

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<CategoricalType>

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

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

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

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

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<Utf8Type>

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<Float64Type>

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

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

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

impl NumOpsDispatchChecked for ChunkedArray<BooleanType>

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

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

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

impl Pow for ChunkedArray<ListType>

fn pow_f32(&self, _exp: f32) -> ChunkedArray<Float32Type>

fn pow_f64(&self, _exp: f64) -> ChunkedArray<Float64Type>

impl Pow for ChunkedArray<CategoricalType>

fn pow_f32(&self, _exp: f32) -> ChunkedArray<Float32Type>

fn pow_f64(&self, _exp: f64) -> ChunkedArray<Float64Type>

impl Pow for ChunkedArray<Utf8Type>

fn pow_f32(&self, _exp: f32) -> ChunkedArray<Float32Type>

fn pow_f64(&self, _exp: f64) -> ChunkedArray<Float64Type>

impl Pow for ChunkedArray<BooleanType>

fn pow_f32(&self, _exp: f32) -> ChunkedArray<Float32Type>

fn pow_f64(&self, _exp: f64) -> ChunkedArray<Float64Type>

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

pub fn pow_f32(&self, exp: f32) -> ChunkedArray<Float32Type>

pub fn pow_f64(&self, exp: f64) -> ChunkedArray<Float64Type>

impl<'_, T> Rem<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    rhs: &'_ ChunkedArray<T>
) -> <&'_ ChunkedArray<T> as Rem<&'_ ChunkedArray<T>>>::Output

Performs the % operation.

impl<T> Rem<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Rem<ChunkedArray<T>>>::Output

Performs the % operation.

impl<T, N> Rem<N> for ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

pub fn rem(self, rhs: N) -> <ChunkedArray<T> as Rem<N>>::Output

Performs the % operation.

impl<'_, T, N> Rem<N> for &'_ ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: One,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

pub fn rem(self, rhs: N) -> <&'_ ChunkedArray<T> as Rem<N>>::Output

Performs the % operation.

impl RepeatBy for ChunkedArray<ListType>

fn repeat_by(&self, _by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

impl RepeatBy for ChunkedArray<CategoricalType>

pub fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

impl RepeatBy for ChunkedArray<Utf8Type>

pub fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

impl<T> RepeatBy for ChunkedArray<ObjectType<T>>

fn repeat_by(&self, _by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

impl RepeatBy for ChunkedArray<BooleanType>

pub fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

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

pub fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>

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

impl<'_, T> Sub<&'_ ChunkedArray<T>> for &'_ ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    rhs: &'_ ChunkedArray<T>
) -> <&'_ ChunkedArray<T> as Sub<&'_ ChunkedArray<T>>>::Output

Performs the - operation.

impl<T> Sub<ChunkedArray<T>> for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: Div<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Rem<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Add<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Mul<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Add<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Mul<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Div<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native,
    <<T as PolarsPrimitiveType>::Native as Rem<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Sub<ChunkedArray<T>>>::Output

Performs the - operation.

impl<'_, T, N> Sub<N> for &'_ ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: N) -> <&'_ ChunkedArray<T> as Sub<N>>::Output

Performs the - operation.

impl<T, N> Sub<N> for ChunkedArray<T> where
    N: Num + ToPrimitive,
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Sub<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Sub<<T as PolarsPrimitiveType>::Native>>::Output == <T as PolarsPrimitiveType>::Native, 

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

pub fn sub(self, rhs: N) -> <ChunkedArray<T> as Sub<N>>::Output

Performs the - operation.

impl<'a, T> TakeRandom for &'a ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NativeType, 

type Item = <T as PolarsPrimitiveType>::Native

pub fn get(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

impl TakeRandom for ChunkedArray<BooleanType>

type Item = bool

pub fn get(
    &self,
    index: usize
) -> Option<<ChunkedArray<BooleanType> as TakeRandom>::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> TakeRandom for &'a ChunkedArray<Utf8Type>

type Item = &'a str

pub fn get(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandom>::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> TakeRandom for ChunkedArray<T> where
    T: PolarsNumericType,
    <T as PolarsPrimitiveType>::Native: NativeType, 

type Item = <T as PolarsPrimitiveType>::Native

pub fn get(&self, index: usize) -> Option<<ChunkedArray<T> as TakeRandom>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<ChunkedArray<T> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

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

type Item = &'a T

pub fn get(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

impl TakeRandom for ChunkedArray<ListType>

type Item = Series

pub fn get(
    &self,
    index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

impl TakeRandom for ChunkedArray<CategoricalType>

type Item = u32

pub fn get(
    &self,
    index: usize
) -> Option<<ChunkedArray<CategoricalType> as TakeRandom>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<ChunkedArray<CategoricalType> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

impl<'a> TakeRandomUtf8 for &'a ChunkedArray<Utf8Type>

type Item = &'a str

pub fn get(
    self,
    index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>

Get a nullable value by index.

pub unsafe fn get_unchecked(
    self,
    index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>

Get a value by index and ignore the null bit.

impl ToDummies<BooleanType> for ChunkedArray<BooleanType>

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

impl ToDummies<CategoricalType> for ChunkedArray<CategoricalType>

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

impl ToDummies<Float32Type> for ChunkedArray<Float32Type>

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

impl ToDummies<Float64Type> for ChunkedArray<Float64Type>

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

impl ToDummies<ListType> for ChunkedArray<ListType>

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

impl<T> ToDummies<ObjectType<T>> for ChunkedArray<ObjectType<T>>

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

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

pub fn to_dummies(&self) -> Result<DataFrame, PolarsError>

impl ToDummies<Utf8Type> for ChunkedArray<Utf8Type>

pub fn to_dummies(&self) -> Result<DataFrame, PolarsError>

impl ValueSize for ChunkedArray<Utf8Type>

pub fn get_values_size(&self) -> usize

Useful for a Utf8 or a List to get underlying value size. During a rechunk this is handy

impl ValueSize for ChunkedArray<ListType>

pub fn get_values_size(&self) -> usize

Useful for a Utf8 or a List to get underlying value size. During a rechunk this is handy

impl<T> VarAggSeries for ChunkedArray<ObjectType<T>>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<Float32Type>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<CategoricalType>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<BooleanType>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl<T> VarAggSeries for ChunkedArray<T> where
    T: PolarsIntegerType,
    <T as PolarsPrimitiveType>::Native: NativeType,
    <T as PolarsPrimitiveType>::Native: PartialOrd<<T as PolarsPrimitiveType>::Native>,
    <T as PolarsPrimitiveType>::Native: Num,
    <T as PolarsPrimitiveType>::Native: NumCast,
    <T as PolarsPrimitiveType>::Native: Zero,
    <T as PolarsPrimitiveType>::Native: Simd,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: Sum<<T as PolarsPrimitiveType>::Native>,
    <<T as PolarsPrimitiveType>::Native as Simd>::Simd: SimdOrd<<T as PolarsPrimitiveType>::Native>,
    <<<T as PolarsPrimitiveType>::Native as Simd>::Simd as Add<<<T as PolarsPrimitiveType>::Native as Simd>::Simd>>::Output == <<T as PolarsPrimitiveType>::Native as Simd>::Simd, 

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<Float64Type>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<ListType>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VarAggSeries for ChunkedArray<Utf8Type>

pub fn var_as_series(&self) -> Series

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

pub fn std_as_series(&self) -> Series

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

impl VecHash for ChunkedArray<Float64Type>

pub fn vec_hash(&self, _random_state: RandomState) -> MutableBuffer<u64>

Compute the hash for all values in the array.

pub fn vec_hash_combine(&self, _random_state: RandomState, _hashes: &mut [u64])

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

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

Compute the hash for all values in the array.

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

impl<T> VecHash for ChunkedArray<T> where
    T: PolarsIntegerType,
    <T as PolarsPrimitiveType>::Native: Hash, 

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

Compute the hash for all values in the array.

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

impl VecHash for ChunkedArray<Float32Type>

pub fn vec_hash(&self, _random_state: RandomState) -> MutableBuffer<u64>

Compute the hash for all values in the array.

pub fn vec_hash_combine(&self, _random_state: RandomState, _hashes: &mut [u64])

impl VecHash for ChunkedArray<ListType>

fn vec_hash(&self, _random_state: RandomState) -> MutableBuffer<u64>

Compute the hash for all values in the array.

fn vec_hash_combine(&self, _random_state: RandomState, _hashes: &mut [u64])

impl VecHash for ChunkedArray<Utf8Type>

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

Compute the hash for all values in the array.

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

impl VecHash for ChunkedArray<BooleanType>

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

Compute the hash for all values in the array.

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

impl<T> ZipOuterJoinColumn for ChunkedArray<ObjectType<T>>

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

impl ZipOuterJoinColumn for ChunkedArray<Utf8Type>

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

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

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

impl ZipOuterJoinColumn for ChunkedArray<CategoricalType>

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

impl ZipOuterJoinColumn for ChunkedArray<BooleanType>

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

impl ZipOuterJoinColumn for ChunkedArray<Float64Type>

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

impl ZipOuterJoinColumn for ChunkedArray<ListType>

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

impl ZipOuterJoinColumn for ChunkedArray<Float32Type>

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