Struct polars::chunked_array::ChunkedArray

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

ChunkedArray

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

fn apply_cosine(ca: &Float32Chunked) -> Float32Chunked {
    ca.apply(|v| v.cos())
}

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

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

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

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

Conversion between Series and ChunkedArray’s

Conversion from a Series to a ChunkedArray is effortless.

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

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

Iterators

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

fn iter_forward(ca: &Float32Chunked) {
    ca.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 many operations that need random access because we have an extra indirection and indexes need to be mapped to the proper chunk. Arithmetic may also be slowed down by this. When multiplying two ChunkArray's with different chunk sizes they cannot utilize SIMD for instance.

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

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

Implementations

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

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

Convert all values to their absolute/positive value.

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

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

Append in place. This is done by adding the chunks of other to this ChunkedArray.

See also extend for appends to the underlying memory

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

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

Cast a numeric array to another numeric data type and apply a function in place. This saves an allocation.

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

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

impl ChunkedArray<Float32Type>

This impl block contains no items.

Used to save compilation paths. Use carefully. Although this is safe, if misused it can lead to incorrect results.

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

pub fn len(&self) -> usize

Get the length of the ChunkedArray

pub fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

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

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

Take a view of top n elements

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

Get the head of the ChunkedArray

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

Get the tail of the ChunkedArray

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

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

Extend the memory backed by this array with the values from other.

Different from ChunkedArray::append which adds chunks to this ChunkedArray extend appends the data from other to the underlying PrimitiveArray and thus may cause a reallocation.

However if this does not cause a reallocation, the resulting data structure will not have any extra chunks and thus will yield faster queries.

Prefer extend over append when you want to do a query after a single append. For instance during online operations where you add n rows and rerun a query.

Prefer append over extend when you want to append many times before doing a query. For instance when you read in multiple files and when to store them in a single DataFrame. In the latter case finish the sequence of append operations with a rechunk.

impl ChunkedArray<ListType>

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

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

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

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

impl ChunkedArray<BooleanType>

pub fn all(&self) -> bool

Check if all values are true

pub fn any(&self) -> bool

Check if any value is true

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

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

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

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

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

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

Convert missing values to NaN values.

impl ChunkedArray<ListType>

pub fn par_iter(&self) -> impl ParallelIterator<Item = Option<Series>>

pub fn par_iter_indexed(&mut self) -> impl IndexedParallelIterator

impl ChunkedArray<Utf8Type>

pub fn par_iter_indexed(&self) -> impl IndexedParallelIterator

pub fn par_iter(&self) -> impl ParallelIterator<Item = Option<&str>>

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

pub fn to_ndarray(
    &self
) -> Result<ArrayBase<ViewRepr<&<T as PolarsNumericType>::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 PolarsNumericType>::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<T>where
    T: PolarsDataType,

pub fn from_chunks(
    name: &str,
    chunks: Vec<Box<dyn Array + 'static, Global>, Global>
) -> ChunkedArray<T>

Create a new ChunkedArray from existing chunks.

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

pub fn from_vec(
    name: &str,
    v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>

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

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

Nullify values in slice with an existing null bitmap

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: FnMut(UnstableSeries<'a>) -> Series,

Apply a closure F elementwise.

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

impl ChunkedArray<ListType>

pub fn set_fast_explode(&mut self)

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

impl ChunkedArray<Int32Type>

pub fn into_date(self) -> Logical<DateType, Int32Type>

impl ChunkedArray<Int64Type>

pub fn into_datetime(
    self,
    timeunit: TimeUnit,
    tz: Option<String>
) -> Logical<DatetimeType, Int64Type>

impl ChunkedArray<Int64Type>

pub fn into_duration(
    self,
    timeunit: TimeUnit
) -> Logical<DurationType, Int64Type>

impl ChunkedArray<Int64Type>

pub fn into_time(self) -> Logical<TimeType, Int64Type>

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
    T: PolarsNumericType,
    Standard: Distribution<<T as PolarsNumericType>::Native>,

pub fn init_rand(
    size: usize,
    null_density: f32,
    seed: Option<u64>
) -> ChunkedArray<T>

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

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

Sample n datapoints from this ChunkedArray.

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

Sample a fraction between 0.0-1.0 of this ChunkedArray.

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

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 hex_decode(
    &self,
    strict: Option<bool>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

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

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

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

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

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

Set the ‘sorted’ bit meta info.

pub fn is_sorted2(&self) -> IsSorted

pub fn set_sorted2(&mut self, sorted: IsSorted)

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

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

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

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

pub fn iter_validities(
    &self
) -> Map<Iter<'_, Box<dyn Array + 'static, Global>>, fn(&Box<dyn Array + 'static, Global>) -> Option<&Bitmap>>

Get the buffer of bits representing null values

pub fn has_validity(&self) -> bool

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

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit its length.

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

Series to ChunkedArray

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

Unique id representing the number of chunks

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

A reference to the chunks

pub unsafe fn chunks_mut(
    &mut self
) -> &mut Vec<Box<dyn Array + 'static, Global>, Global>

A mutable reference to the chunks

Safety

The caller must ensure to not change the DataType or length of any of the chunks.

pub fn is_optimal_aligned(&self) -> bool

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

pub fn null_count(&self) -> usize

Count the null values.

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

Append arrow array in place.

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

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

pub fn is_null(&self) -> 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 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: PolarsNumericType,

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

Contiguous slice

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

impl ChunkedArray<ListType>

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the list.

pub fn set_inner_dtype(&mut self, dtype: DataType)

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

pub fn new_vec(
    name: &str,
    v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>

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

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

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

pub fn lhs_sub<N>(&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,

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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.

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.

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,

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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.

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
    T: PolarsNumericType,
    N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AggList for ChunkedArray<BooleanType>

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

impl AggList for ChunkedArray<ListType>

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

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

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

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

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

impl AggList for ChunkedArray<Utf8Type>

unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series

Safety

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

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

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

Get the index of the minimal value

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

Get the index of the maximal value

impl 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 AsList for ChunkedArray<ListType>

fn as_list(&self) -> &ChunkedArray<ListType>

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

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

Converts this type into a mutable reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Converts this type into a shared reference of the (usually inferred) input type.

impl AsUtf8 for ChunkedArray<Utf8Type>

fn as_utf8(&self) -> &ChunkedArray<Utf8Type>

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T> BitAnd<&ChunkedArray<T>> for &ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: BitAnd<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as BitAnd<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,

type Output = ChunkedArray<T>

The resulting type after applying the & operator.

fn bitand(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitAnd<&ChunkedArray<T>>>::Output

Performs the & operation.

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

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.

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

Performs the | operation.

impl<T> BitOr<&ChunkedArray<T>> for &ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: BitOr<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as BitOr<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,

type Output = ChunkedArray<T>

The resulting type after applying the | operator.

fn bitor(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitOr<&ChunkedArray<T>>>::Output

Performs the | operation.

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitXor<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.

fn bitxor(
    self,
    rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitXor<&ChunkedArray<BooleanType>>>::Output

Performs the ^ operation.

impl<T> BitXor<&ChunkedArray<T>> for &ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: BitXor<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as BitXor<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,

type Output = ChunkedArray<T>

The resulting type after applying the ^ operator.

fn bitxor(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitXor<&ChunkedArray<T>>>::Output

Performs the ^ operation.

impl BitXor<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.

fn bitxor(
    self,
    rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitXor<ChunkedArray<BooleanType>>>::Output

Performs the ^ operation.

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

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

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

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

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

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

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

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

impl ChunkAgg<u32> for ChunkedArray<BooleanType>

Booleans are casted to 1 or 0.

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

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

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

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.

impl ChunkAggSeries for ChunkedArray<BooleanType>

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 prod_as_series(&self) -> Series

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

impl ChunkAggSeries for ChunkedArray<ListType>

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 prod_as_series(&self) -> Series

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

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

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 prod_as_series(&self) -> Series

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

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

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 prod_as_series(&self) -> Series

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

impl ChunkAggSeries for ChunkedArray<Utf8Type>

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 prod_as_series(&self) -> Series

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

impl ChunkAnyValue for ChunkedArray<BooleanType>

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

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

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

Get a single value. Beware this is slow.

impl ChunkAnyValue for ChunkedArray<ListType>

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

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

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

Get a single value. Beware this is slow.

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

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

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

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

Get a single value. Beware this is slow.

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

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

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

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

Get a single value. Beware this is slow.

impl ChunkAnyValue for ChunkedArray<Utf8Type>

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

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

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

Get a single value. Beware this is slow.

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

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

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

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

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

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.

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

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.

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.

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.

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>

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

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

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

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

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.

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

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.

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.

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.

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

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

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

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

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

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

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

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

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

Apply a closure elementwise including null values.

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

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

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

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

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

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

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

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

Apply a closure F elementwise.

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.

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.

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

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

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

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

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

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.

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>

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

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

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

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

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.

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

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.

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.

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.

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>

fn apply_kernel(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<BooleanType>

Apply kernel and return result as a new ChunkedArray.

fn apply_kernel_cast<S>(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<S>where
    S: PolarsDataType,

Apply a kernel that outputs an array of different type.

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

fn apply_kernel(
    &self,
    f: &dyn Fn(&PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>

Apply kernel and return result as a new ChunkedArray.

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

Apply a kernel that outputs an array of different type.

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

fn apply_kernel(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<Utf8Type>

Apply kernel and return result as a new ChunkedArray.

fn apply_kernel_cast<S>(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<S>where
    S: PolarsDataType,

Apply a kernel that outputs an array of different type.

impl ChunkCast for ChunkedArray<BooleanType>

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

Cast a [ChunkedArray] to [DataType]

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

Does not check if the cast is a valid one and may over/underflow

impl ChunkCast for ChunkedArray<ListType>

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

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

Cast a [ChunkedArray] to [DataType]

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

Does not check if the cast is a valid one and may over/underflow

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

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

Cast a [ChunkedArray] to [DataType]

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

Does not check if the cast is a valid one and may over/underflow

impl ChunkCast for ChunkedArray<Utf8Type>

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

Cast a [ChunkedArray] to [DataType]

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

Does not check if the cast is a valid one and may over/underflow

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

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

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

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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,

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

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

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkCompare<&str> for ChunkedArray<Utf8Type>

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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: ToPrimitive,

type Item = ChunkedArray<BooleanType>

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

Check for equality and regard missing values as equal.

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

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

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

Get an array with the cumulative max computed at every element

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

Get an array with the cumulative min computed at every element

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

Get an array with the cumulative sum computed at every element

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

Get an array with the cumulative product computed at every element

impl ChunkExpandAtIndex<BooleanType> for ChunkedArray<BooleanType>

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

Create a new ChunkedArray filled with values at that index.

impl ChunkExpandAtIndex<ListType> for ChunkedArray<ListType>

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

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: PolarsDataType + PolarsNumericType,
    ChunkedArray<T>: ChunkFull<<T as PolarsNumericType>::Native>,
    ChunkedArray<T>: TakeRandom,
    <ChunkedArray<T> as TakeRandom>::Item == <T as PolarsNumericType>::Native,

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>

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<ListType>

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

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

impl ChunkExplode for ChunkedArray<Utf8Type>

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

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

impl ChunkFillNull for ChunkedArray<BooleanType>

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

Replace None values with one of the following strategies:

impl ChunkFillNull for ChunkedArray<ListType>

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

Replace None values with one of the following strategies:

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

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

Replace None values with one of the following strategies:

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

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

Replace None values with one of the following strategies:

impl ChunkFillNull for ChunkedArray<Utf8Type>

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

Replace None values with one of the following strategies:

impl ChunkFillNullValue<&Series> for ChunkedArray<ListType>

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>

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

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

Replace None values with a give value T.

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

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>

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>

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

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFilter<ListType> for ChunkedArray<ListType>

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,

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,

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>

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

Filter values in the ChunkedArray with a boolean mask.

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

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

Create a ChunkedArray with a single value.

impl ChunkFull<&Series> for ChunkedArray<ListType>

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

Create a ChunkedArray with a single value.

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

fn full(
    name: &str,
    value: <T as PolarsNumericType>::Native,
    length: usize
) -> ChunkedArray<T>

Create a ChunkedArray with a single value.

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

fn full(name: &str, value: T, length: usize) -> ChunkedArray<ObjectType<T>>where
    ChunkedArray<ObjectType<T>>: Sized,

Create a ChunkedArray with a single value.

impl ChunkFull<bool> for ChunkedArray<BooleanType>

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

Create a ChunkedArray with a single value.

impl ChunkFullNull for ChunkedArray<BooleanType>

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

impl ChunkFullNull for ChunkedArray<ListType>

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

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

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

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

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

impl ChunkFullNull for ChunkedArray<Utf8Type>

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

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

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 ChunkQuantile<Series> for ChunkedArray<ListType>

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

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

fn quantile(
    &self,
    _quantile: f64,
    _interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>

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

impl<T> ChunkQuantile<Series> for ChunkedArray<ObjectType<T>>where
    T: PolarsObject,

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

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

fn quantile(
    &self,
    _quantile: f64,
    _interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>

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

impl ChunkQuantile<String> for ChunkedArray<Utf8Type>

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

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

fn quantile(
    &self,
    _quantile: f64,
    _interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>

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

impl ChunkQuantile<bool> for ChunkedArray<BooleanType>

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

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

fn quantile(
    &self,
    _quantile: f64,
    _interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>

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

impl ChunkQuantile<f32> for ChunkedArray<Float32Type>

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

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

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

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

impl ChunkQuantile<f64> for ChunkedArray<Float64Type>

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

Aggregate a given quantile of the ChunkedArray. 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.

impl<T> ChunkQuantile<f64> for ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: Ord,
    <<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
    <<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,

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

Aggregate a given quantile of the ChunkedArray. 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.

impl ChunkReverse<BooleanType> for ChunkedArray<BooleanType>

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

Return a reversed version of this array.

impl ChunkReverse<ListType> for ChunkedArray<ListType>

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

Return a reversed version of this array.

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

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

Return a reversed version of this array.

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

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

Return a reversed version of this array.

impl ChunkReverse<Utf8Type> for ChunkedArray<Utf8Type>

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

Return a reversed version of this array.

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

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

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

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

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

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

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

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

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>.

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

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

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

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

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

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

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

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

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

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

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

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

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>.

impl ChunkShift<BooleanType> for ChunkedArray<BooleanType>

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

impl ChunkShift<ListType> for ChunkedArray<ListType>

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

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

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

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

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

impl ChunkShift<Utf8Type> for ChunkedArray<Utf8Type>

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

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

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>

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

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

fn shift_and_fill(
    &self,
    periods: i64,
    fill_value: Option<<T as PolarsNumericType>::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>

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>

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

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

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> 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<Float32Type> for ChunkedArray<Float32Type>

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

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

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

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl ChunkSort<Float64Type> for ChunkedArray<Float64Type>

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

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

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

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl<T> ChunkSort<T> for ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: Default,
    <T as PolarsNumericType>::Native: Ord,

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

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

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

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl ChunkSort<Utf8Type> for ChunkedArray<Utf8Type>

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.

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

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

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>

Retrieve the indexes needed to sort this array.

impl ChunkTake for ChunkedArray<BooleanType>

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.

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

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.

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

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.

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

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.

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

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.

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

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

Traverse and collect every nth element in a new array.

impl ChunkTakeEvery<ListType> for ChunkedArray<ListType>

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

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,

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

Traverse and collect every nth element in a new array.

impl ChunkTakeEvery<Utf8Type> for ChunkedArray<Utf8Type>

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

Traverse and collect every nth element in a new array.

impl ChunkUnique<BooleanType> for ChunkedArray<BooleanType>

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

Get unique values of a ChunkedArray

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

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

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 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<Float32Type> for ChunkedArray<Float32Type>

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

Get unique values of a ChunkedArray

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

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

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

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

Get unique values of a ChunkedArray

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

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

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

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

Get unique values of a ChunkedArray

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 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 PolarsNumericType>::Native: Hash,
    <T as PolarsNumericType>::Native: Eq,
    <T as PolarsNumericType>::Native: Ord,
    ChunkedArray<T>: IntoSeries,

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

Get unique values of a ChunkedArray

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

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

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

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

Get unique values of a ChunkedArray

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

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

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 n_unique(&self) -> Result<usize, PolarsError>

Number of unique values in the ChunkedArray

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

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

impl ChunkVar<Series> for ChunkedArray<ListType>

fn var(&self, _ddof: u8) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self, _ddof: u8) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkVar<Series> for ChunkedArray<ObjectType<T>>where
    T: PolarsObject,

fn var(&self, _ddof: u8) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self, _ddof: u8) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<String> for ChunkedArray<Utf8Type>

fn var(&self, _ddof: u8) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self, _ddof: u8) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<bool> for ChunkedArray<BooleanType>

fn var(&self, _ddof: u8) -> Option<T>

Compute the variance of this ChunkedArray/Series.

fn std(&self, _ddof: u8) -> Option<T>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<f32> for ChunkedArray<Float32Type>

fn var(&self, ddof: u8) -> Option<f32>

Compute the variance of this ChunkedArray/Series.

fn std(&self, ddof: u8) -> Option<f32>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkVar<f64> for ChunkedArray<Float64Type>

fn var(&self, ddof: u8) -> Option<f64>

Compute the variance of this ChunkedArray/Series.

fn std(&self, ddof: u8) -> Option<f64>

Compute the standard deviation of this ChunkedArray/Series.

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

fn var(&self, ddof: u8) -> Option<f64>

Compute the variance of this ChunkedArray/Series.

fn std(&self, ddof: u8) -> Option<f64>

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkZip<BooleanType> for ChunkedArray<BooleanType>

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

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,

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,

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>

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<'a> ChunkedSet<&'a str> for &'a ChunkedArray<Utf8Type>

fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
    V: IntoIterator<Item = Option<&'a str>>,

impl<T> ChunkedSet<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
    T: PolarsOpsNumericType,
    ChunkedArray<T>: IntoSeries,

fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
    V: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,

impl ChunkedSet<bool> for &ChunkedArray<BooleanType>

fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
    V: IntoIterator<Item = Option<bool>>,

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

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>

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<ListType>

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,

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl Debug for ChunkedArray<Utf8Type>

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

Formats the value using the given formatter.

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

fn default() -> ChunkedArray<T>

Returns the “default value” for a type.

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

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn drop(&mut self)

Executes the destructor for this type.

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

fn from(ca: &'a ChunkedArray<BooleanType>) -> Vec<Option<bool>, Global>

Converts to this type from the input type.

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

fn from(
    ca: &'a ChunkedArray<T>
) -> Vec<Option<<T as PolarsNumericType>::Native>, Global>

Converts to this type from the input type.

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

Conversion from UInt32Chunked to Unchecked TakeIdx

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

Converts to this type from the input type.

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

From trait

fn from(ca: &'a ChunkedArray<Utf8Type>) -> Vec<Option<&'a str>, Global>

Converts to this type from the input type.

impl<T> From<&[<T as PolarsNumericType>::Native]> for ChunkedArray<T>where
    T: PolarsNumericType,

fn from(slice: &[<T as PolarsNumericType>::Native]) -> ChunkedArray<T>

Converts to this type from the input type.

impl From<(&str, BooleanArray)> for ChunkedArray<BooleanType>

fn from(tpl: (&str, BooleanArray)) -> ChunkedArray<BooleanType>

Converts to this type from the input type.

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

fn from(
    tpl: (&str, PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>

Converts to this type from the input type.

impl From<(&str, Utf8Array<i64>)> for ChunkedArray<Utf8Type>

fn from(tpl: (&str, Utf8Array<i64>)) -> ChunkedArray<Utf8Type>

Converts to this type from the input type.

impl From<BooleanArray> for ChunkedArray<BooleanType>

fn from(arr: BooleanArray) -> ChunkedArray<BooleanType>

Converts to this type from the input type.

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

fn from(ca: ChunkedArray<BooleanType>) -> Vec<Option<bool>, Global>

Converts to this type from the input type.

impl From<ChunkedArray<Int32Type>> for Logical<DateType, Int32Type>

fn from(ca: ChunkedArray<Int32Type>) -> Logical<DateType, Int32Type>

Converts to this type from the input type.

impl From<ChunkedArray<Int64Type>> for Logical<TimeType, Int64Type>

fn from(ca: ChunkedArray<Int64Type>) -> Logical<TimeType, Int64Type>

Converts to this type from the input type.

impl<T> From<ChunkedArray<T>> for Serieswhere
    T: PolarsDataType,
    ChunkedArray<T>: IntoSeries,

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

Converts to this type from the input type.

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

fn from(ca: ChunkedArray<Utf8Type>) -> Vec<Option<String>, Global>

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from_iter<I>(iter: I) -> ChunkedArray<T>where
    I: IntoIterator<Item = (Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)>,

Creates a value from an iterator.

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

FromIterator trait

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

Creates a value from an iterator.

impl FromIterator<Option<Box<dyn Array + 'static, Global>>> for ChunkedArray<ListType>

fn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
    I: IntoIterator<Item = Option<Box<dyn Array + 'static, Global>>>,

Creates a value from an iterator.

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

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

Creates a value from an iterator.

impl FromIterator<Option<Series>> for ChunkedArray<ListType>

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

Creates a value from an iterator.

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

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>

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>,

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>,

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>

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

Creates a value from an iterator.

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

fn from_trusted_len_iter_rev<I>(iter: I) -> ChunkedArray<T>where
    I: TrustedLen<Item = Option<<T as PolarsNumericType>::Native>>,

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

fn from_trusted_len_iter_rev<I>(iter: I) -> ChunkedArray<BooleanType>where
    I: TrustedLen<Item = Option<bool>>,

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

fn from_par_iter<I>(iter: I) -> ChunkedArray<T>where
    I: IntoParallelIterator<Item = Option<<T as PolarsNumericType>::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,

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 FromParallelIterator<Option<Series>> for ChunkedArray<ListType>

fn from_par_iter<I>(iter: I) -> ChunkedArray<ListType>where
    I: IntoParallelIterator<Item = Option<Series>>,

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,

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>

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

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<T>where
    I: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,

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

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

impl FromTrustedLenIterator<Option<Series>> for ChunkedArray<ListType>

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ListType>where
    I: IntoIterator<Item = Option<Series>>,

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

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

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

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<ListType>where
    Ptr: Borrow<Series>,

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

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

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

impl FromTrustedLenIterator<bool> for ChunkedArray<BooleanType>

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<BooleanType>where
    I: IntoIterator<Item = bool>,
    <I as IntoIterator>::IntoIter: TrustedLen,

impl Interpolate for ChunkedArray<Float32Type>

fn interpolate(&self) -> ChunkedArray<Float32Type>

impl Interpolate for ChunkedArray<Float64Type>

fn interpolate(&self) -> ChunkedArray<Float64Type>

impl Interpolate for ChunkedArray<Int16Type>

fn interpolate(&self) -> ChunkedArray<Int16Type>

impl Interpolate for ChunkedArray<Int32Type>

fn interpolate(&self) -> ChunkedArray<Int32Type>

impl Interpolate for ChunkedArray<Int64Type>

fn interpolate(&self) -> ChunkedArray<Int64Type>

impl Interpolate for ChunkedArray<Int8Type>

fn interpolate(&self) -> ChunkedArray<Int8Type>

impl Interpolate for ChunkedArray<UInt16Type>

fn interpolate(&self) -> ChunkedArray<UInt16Type>

impl Interpolate for ChunkedArray<UInt32Type>

fn interpolate(&self) -> ChunkedArray<UInt32Type>

impl Interpolate for ChunkedArray<UInt64Type>

fn interpolate(&self) -> ChunkedArray<UInt64Type>

impl Interpolate for ChunkedArray<UInt8Type>

fn interpolate(&self) -> ChunkedArray<UInt8Type>

impl IntoGroupsProxy for ChunkedArray<BooleanType>

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

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

fn group_tuples(&self, _multithreaded: bool, _sorted: bool) -> GroupsProxy

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

fn group_tuples(&self, _multithreaded: bool, sorted: bool) -> GroupsProxy

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> IntoGroupsProxy for ChunkedArray<T>where
    T: PolarsNumericType,
    <T as PolarsNumericType>::Native: NumCast,

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

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

fn group_tuples(&'a self, multithreaded: bool, sorted: bool) -> GroupsProxy

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?

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?

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?

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 PolarsNumericType>::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?

fn into_iter(self) -> <&'a ChunkedArray<T> 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?

fn into_iter(self) -> <&'a ChunkedArray<Utf8Type> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IntoSeries for ChunkedArray<T>where
    T: 'static + PolarsDataType,
    SeriesWrap<ChunkedArray<T>>: SeriesTrait,

fn into_series(self) -> Serieswhere
    ChunkedArray<T>: Sized,

fn is_series() -> bool

impl<T> IntoSeriesOps for &ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: NumericNative,

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl<T> IntoSeriesOps for &ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: NumericNative,

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl IntoSeriesOps for ChunkedArray<BooleanType>

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl IntoSeriesOps for ChunkedArray<BooleanType>

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl IntoSeriesOps for ChunkedArray<Float32Type>

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl IntoSeriesOps for ChunkedArray<Float32Type>

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl IntoSeriesOps for ChunkedArray<Float64Type>

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl IntoSeriesOps for ChunkedArray<Float64Type>

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl IntoSeriesOps for ChunkedArray<ListType>

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl IntoSeriesOps for ChunkedArray<ListType>

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl IntoSeriesOps for ChunkedArray<Utf8Type>

fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>

impl IntoSeriesOps for ChunkedArray<Utf8Type>

fn to_ops(&self) -> Arc<dyn SeriesOps + 'static>

impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<BooleanType>

type Item = bool

type TakeRandom = TakeRandBranch2<BoolTakeRandomSingleChunk<'a>, BoolTakeRandom<'a>>

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

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

type Item = &'a T

type TakeRandom = TakeRandBranch2<ObjectTakeRandomSingleChunk<'a, T>, ObjectTakeRandom<'a, T>>

fn take_rand(
    &self
) -> <&'a ChunkedArray<ObjectType<T>> 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 PolarsNumericType>::Native

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

fn take_rand(&self) -> <&'a ChunkedArray<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>>

fn take_rand(
    &self
) -> <&'a ChunkedArray<Utf8Type> as IntoTakeRandom<'a>>::TakeRandom

Create a type that implements TakeRandom.

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

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

impl IsFirst<Utf8Type> for ChunkedArray<Utf8Type>

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

impl IsIn for ChunkedArray<BooleanType>

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

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>

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

fn lst_join(
    &self,
    separator: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

In case the inner dtype DataType::Utf8, the individual items will be joined into a single string separated by separator.

fn lst_max(&self) -> Series

fn lst_min(&self) -> Series

fn lst_sum(&self) -> Series

fn lst_mean(&self) -> ChunkedArray<Float64Type>

fn lst_sort(&self, reverse: bool) -> ChunkedArray<ListType>

fn lst_reverse(&self) -> ChunkedArray<ListType>

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

fn lst_arg_min(&self) -> ChunkedArray<UInt32Type>

fn lst_arg_max(&self) -> ChunkedArray<UInt32Type>

fn lst_diff(
    &self,
    n: usize,
    null_behavior: NullBehavior
) -> ChunkedArray<ListType>

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

fn lst_slice(&self, offset: i64, length: usize) -> ChunkedArray<ListType>

fn lst_lengths(&self) -> ChunkedArray<UInt32Type>

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

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

fn lst_concat(
    &self,
    other: &[Series]
) -> Result<ChunkedArray<ListType>, PolarsError>

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

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Mul<&ChunkedArray<T>>>::Output

Performs the * operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

fn mul(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Mul<ChunkedArray<T>>>::Output

Performs the * operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> <&ChunkedArray<T> as Mul<N>>::Output

Performs the * operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> <ChunkedArray<T> as Mul<N>>::Output

Performs the * operation.

impl<T> NamedFrom<&[T], &[T]> for ChunkedArray<ObjectType<T>>where
    T: PolarsObject,

fn new(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>

Initialize by name and values.

impl NamedFrom<Range<i32>, Int32Type> for ChunkedArray<Int32Type>

fn new(name: &str, range: Range<i32>) -> ChunkedArray<Int32Type>

Initialize by name and values.

impl NamedFrom<Range<i64>, Int64Type> for ChunkedArray<Int64Type>

fn new(name: &str, range: Range<i64>) -> ChunkedArray<Int64Type>

Initialize by name and values.

impl NamedFrom<Range<u32>, UInt32Type> for ChunkedArray<UInt32Type>

fn new(name: &str, range: Range<u32>) -> ChunkedArray<UInt32Type>

Initialize by name and values.

impl NamedFrom<Range<u64>, UInt64Type> for ChunkedArray<UInt64Type>

fn new(name: &str, range: Range<u64>) -> ChunkedArray<UInt64Type>

Initialize by name and values.

impl<T, S> NamedFrom<S, [Option<T>]> for ChunkedArray<ObjectType<T>>where
    T: PolarsObject,
    S: AsRef<[Option<T>]>,

fn new(name: &str, v: S) -> ChunkedArray<ObjectType<T>>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [&'a str]> for ChunkedArray<Utf8Type>where
    T: AsRef<[&'a str]>,

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Cow<'a, str>]> for ChunkedArray<Utf8Type>where
    T: AsRef<[Cow<'a, str>]>,

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Option<&'a str>]> for ChunkedArray<Utf8Type>where
    T: AsRef<[Option<&'a str>]>,

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Option<Cow<'a, str>>]> for ChunkedArray<Utf8Type>where
    T: AsRef<[Option<Cow<'a, str>>]>,

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<BooleanType>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Float32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Float64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<i16>]> for ChunkedArray<Int16Type>where
    T: AsRef<[Option<i16>]>,

fn new(name: &str, v: T) -> ChunkedArray<Int16Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Int32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<i8>]> for ChunkedArray<Int8Type>where
    T: AsRef<[Option<i8>]>,

fn new(name: &str, v: T) -> ChunkedArray<Int8Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<u16>]> for ChunkedArray<UInt16Type>where
    T: AsRef<[Option<u16>]>,

fn new(name: &str, v: T) -> ChunkedArray<UInt16Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<UInt32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<UInt64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<u8>]> for ChunkedArray<UInt8Type>where
    T: AsRef<[Option<u8>]>,

fn new(name: &str, v: T) -> ChunkedArray<UInt8Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<BooleanType>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Float32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Float64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [i16]> for ChunkedArray<Int16Type>where
    T: AsRef<[i16]>,

fn new(name: &str, v: T) -> ChunkedArray<Int16Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Int32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [i8]> for ChunkedArray<Int8Type>where
    T: AsRef<[i8]>,

fn new(name: &str, v: T) -> ChunkedArray<Int8Type>

Initialize by name and values.

impl<T> NamedFrom<T, [u16]> for ChunkedArray<UInt16Type>where
    T: AsRef<[u16]>,

fn new(name: &str, v: T) -> ChunkedArray<UInt16Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<UInt32Type>

Initialize by name and values.

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

fn new(name: &str, v: T) -> ChunkedArray<UInt64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [u8]> for ChunkedArray<UInt8Type>where
    T: AsRef<[u8]>,

fn new(name: &str, v: T) -> ChunkedArray<UInt8Type>

Initialize by name and values.

impl NewChunkedArray<BooleanType, bool> for ChunkedArray<BooleanType>

fn from_iter_values(
    name: &str,
    it: impl Iterator<Item = bool>
) -> ChunkedArray<BooleanType>

Create a new ChunkedArray from an iterator.

fn from_slice(name: &str, v: &[bool]) -> ChunkedArray<BooleanType>

fn from_slice_options(
    name: &str,
    opt_v: &[Option<bool>]
) -> ChunkedArray<BooleanType>

fn from_iter_options(
    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,

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

Create a new ChunkedArray from an iterator.

fn from_slice(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>

fn from_slice_options(
    name: &str,
    opt_v: &[Option<T>]
) -> ChunkedArray<ObjectType<T>>

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

Create a new ChunkedArray from an iterator.

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

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

Create a new ChunkedArray from an iterator.

fn from_slice(
    name: &str,
    v: &[<T as PolarsNumericType>::Native]
) -> ChunkedArray<T>

fn from_slice_options(
    name: &str,
    opt_v: &[Option<<T as PolarsNumericType>::Native>]
) -> ChunkedArray<T>

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

Create a new ChunkedArray from an iterator.

impl<S> NewChunkedArray<Utf8Type, S> for ChunkedArray<Utf8Type>where
    S: AsRef<str>,

fn from_iter_values(
    name: &str,
    it: impl Iterator<Item = S>
) -> ChunkedArray<Utf8Type>

Create a new ChunkedArray from an iterator.

fn from_slice(name: &str, v: &[S]) -> ChunkedArray<Utf8Type>

fn from_slice_options(name: &str, opt_v: &[Option<S>]) -> ChunkedArray<Utf8Type>

fn from_iter_options(
    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.

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.

fn not(self) -> <ChunkedArray<BooleanType> as Not>::Output

Performs the unary ! operation.

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

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

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 NumOpsDispatchChecked for ChunkedArray<Float32Type>

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>

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 PolarsNumericType>::Native: CheckedDiv,
    <T as PolarsNumericType>::Native: CheckedDiv,
    <T as PolarsNumericType>::Native: Zero,
    <T as PolarsNumericType>::Native: One,
    ChunkedArray<T>: IntoSeries,
    <<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
    <<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,

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

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

Get the quantile 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.

impl QuantileAggSeries for ChunkedArray<Float32Type>

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

Get the quantile 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.

impl QuantileAggSeries for ChunkedArray<Float64Type>

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

Get the quantile 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.

impl QuantileAggSeries for ChunkedArray<ListType>

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

Get the quantile 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.

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

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

Get the quantile 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.

impl<T> QuantileAggSeries for ChunkedArray<T>where
    T: PolarsIntegerType,
    <T as PolarsNumericType>::Native: Ord,
    <<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
    <<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,

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

Get the quantile 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.

impl QuantileAggSeries for ChunkedArray<Utf8Type>

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

Get the quantile 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.

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

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Rem<&ChunkedArray<T>>>::Output

Performs the % operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Rem<ChunkedArray<T>>>::Output

Performs the % operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: N) -> <&ChunkedArray<T> as Rem<N>>::Output

Performs the % operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

fn rem(self, rhs: N) -> <ChunkedArray<T> as Rem<N>>::Output

Performs the % operation.

impl RepeatBy for ChunkedArray<BooleanType>

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,

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>

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> StrConcat for ChunkedArray<T>where
    T: PolarsNumericType,
    <T as PolarsNumericType>::Native: Display,

fn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>

Concat the values into a string array.

impl StrConcat for ChunkedArray<Utf8Type>

fn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>

Concat the values into a string array.

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

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

fn sub(
    self,
    rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Sub<&ChunkedArray<T>>>::Output

Performs the - operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

fn sub(
    self,
    rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Sub<ChunkedArray<T>>>::Output

Performs the - operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

fn sub(self, rhs: N) -> <&ChunkedArray<T> as Sub<N>>::Output

Performs the - operation.

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

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

fn sub(self, rhs: N) -> <ChunkedArray<T> as Sub<N>>::Output

Performs the - operation.

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

type Item = &'a T

fn get(
    &self,
    index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>

Get a nullable value by index.

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<'a, T> TakeRandom for &'a ChunkedArray<T>where
    T: PolarsNumericType,

type Item = <T as PolarsNumericType>::Native

fn get(&self, index: usize) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>

Get a nullable value by index.

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<'a> TakeRandom for &'a ChunkedArray<Utf8Type>

type Item = &'a str

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

type Item = bool

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

type Item = Series

fn get(
    &self,
    index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>

Get a nullable value by index.

unsafe fn get_unchecked(
    &self,
    index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>

Get a value by index and ignore the null bit.

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

type Item = <T as PolarsNumericType>::Native

fn get(&self, index: usize) -> Option<<ChunkedArray<T> as TakeRandom>::Item>

Get a nullable value by index.

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> TakeRandomUtf8 for &'a ChunkedArray<Utf8Type>

type Item = &'a str

fn get(
    self,
    index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>

Get a nullable value by index.

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<T> ToDummies<T> for ChunkedArray<T>where
    T: PolarsIntegerType + Sync,
    <T as PolarsNumericType>::Native: NumericNative,

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

impl Utf8Methods for ChunkedArray<Utf8Type>

fn as_time(
    &self,
    fmt: Option<&str>
) -> Result<Logical<TimeType, Int64Type>, PolarsError>

Parsing string values and return a TimeChunked

fn as_date_not_exact(
    &self,
    fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>

Parsing string values and return a DateChunked Different from as_date this function allows matches that not contain the whole string e.g. “foo-2021-01-01-bar” could match “2021-01-01”

fn as_datetime_not_exact(
    &self,
    fmt: Option<&str>,
    tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Parsing string values and return a DatetimeChunked Different from as_datetime this function allows matches that not contain the whole string e.g. “foo-2021-01-01-bar” could match “2021-01-01”

fn as_date(
    &self,
    fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>

Parsing string values and return a DateChunked

fn as_datetime(
    &self,
    fmt: Option<&str>,
    tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Parsing string values and return a DatetimeChunked

impl Utf8NameSpaceImpl for ChunkedArray<Utf8Type>

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

Get the length of the string values.

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

Check if strings contain a regex pattern; take literal fast-path if no special chars and strlen <= 96 chars (otherwise regex faster).

fn contains_literal(
    &self,
    lit: &str
) -> Result<ChunkedArray<BooleanType>, PolarsError>

Check if strings contain a given literal

fn ends_with(&self, sub: &str) -> ChunkedArray<BooleanType>

Check if strings ends with a substring

fn starts_with(&self, sub: &str) -> ChunkedArray<BooleanType>

Check if strings starts with a substring

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

Replace the leftmost regex-matched (sub)string with another string; take fast-path for small (<= 32 chars) strings (otherwise regex faster).

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

Replace the leftmost literal (sub)string with another string

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

Replace all regex-matched (sub)strings with another string

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

Replace all matching literal (sub)strings with another string

fn extract(
    &self,
    pat: &str,
    group_index: usize
) -> Result<ChunkedArray<Utf8Type>, PolarsError>

Extract the nth capture group from pattern

fn extract_all(&self, pat: &str) -> Result<ChunkedArray<ListType>, PolarsError>

Extract each successive non-overlapping regex match in an individual string as an array

fn count_match(&self, pat: &str) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Count all successive non-overlapping regex matches.

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

Modify the strings to their lowercase equivalent

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

Modify the strings to their uppercase equivalent

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

Concat with the values from a second Utf8Chunked

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

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

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

fn var_as_series(&self, _ddof: u8) -> Series

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

fn std_as_series(&self, _ddof: u8) -> Series

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

impl VarAggSeries for ChunkedArray<Float32Type>

fn var_as_series(&self, ddof: u8) -> Series

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

fn std_as_series(&self, ddof: u8) -> Series

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

impl VarAggSeries for ChunkedArray<Float64Type>

fn var_as_series(&self, ddof: u8) -> Series

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

fn std_as_series(&self, ddof: u8) -> Series

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

impl VarAggSeries for ChunkedArray<ListType>

fn var_as_series(&self, _ddof: u8) -> Series

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

fn std_as_series(&self, _ddof: u8) -> Series

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

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

fn var_as_series(&self, _ddof: u8) -> Series

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

fn std_as_series(&self, _ddof: u8) -> 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 PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
    <<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
    <<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,

fn var_as_series(&self, ddof: u8) -> Series

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

fn std_as_series(&self, ddof: u8) -> Series

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

impl VarAggSeries for ChunkedArray<Utf8Type>

fn var_as_series(&self, _ddof: u8) -> Series

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

fn std_as_series(&self, _ddof: u8) -> Series

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

impl VecHash for ChunkedArray<BooleanType>

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

Compute the hash for all values in the array.

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

impl VecHash for ChunkedArray<Float32Type>

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

Compute the hash for all values in the array.

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

impl VecHash for ChunkedArray<Float64Type>

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

Compute the hash for all values in the array.

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

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

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

Compute the hash for all values in the array.

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

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

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

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>

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

Compute the hash for all values in the array.

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

impl ZipOuterJoinColumn for ChunkedArray<BooleanType>

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

impl ZipOuterJoinColumn for ChunkedArray<Float64Type>

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,

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

impl ZipOuterJoinColumn for ChunkedArray<Utf8Type>

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