Struct polars::chunked_array::ChunkedArray

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

§ChunkedArray

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

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

§Conversion between Series and ChunkedArray’s

Conversion from a Series to a ChunkedArray is effortless.

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

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

§Iterators

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


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

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

§Memory layout

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

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

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

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

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

§Invariants

Implementations§

source§

impl ChunkedArray<BooleanType>

Booleans are casted to 1 or 0.

source

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

source

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

source

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

source

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

source§

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

source

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

source§

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

source

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

source

pub fn apply_nonnull_values_generic<'a, U, K, F>( &'a self, dtype: DataType, op: F ) -> ChunkedArray<U>

Applies a function only to the non-null elements, propagating nulls.

source

pub fn try_apply_nonnull_values_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>

Applies a function only to the non-null elements, propagating nulls.

source

pub fn apply_generic<'a, U, K, F>(&'a self, op: F) -> ChunkedArray<U>

source

pub fn try_apply_generic<'a, U, K, F, E>( &'a self, op: F ) -> Result<ChunkedArray<U>, E>

source§

impl<T> ChunkedArray<T>

source

pub fn cast_and_apply_in_place<F, S>(&self, f: F) -> ChunkedArray<S>

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

source

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

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

source§

impl<T> ChunkedArray<T>

source

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

source§

impl ChunkedArray<StringType>

source

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

source

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

Utility that reuses an string buffer to amortize allocations. Prefer this over an apply that returns an owned String.

source§

impl ChunkedArray<BinaryType>

source

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

source§

impl ChunkedArray<Float32Type>

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

source

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

source§

impl ChunkedArray<Float64Type>

source

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

source§

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

source

pub fn len(&self) -> usize

Get the length of the ChunkedArray

source

pub fn null_count(&self) -> usize

Return the number of null values in the ChunkedArray.

source

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

Set the null count directly.

This can be useful after mutably adjusting the validity of the underlying arrays.

§Safety

The new null count must match the total null count of the underlying arrays.

source

pub fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

source

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

source

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

source

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

Take a view of top n elements

source

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

Get the head of the ChunkedArray

source

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

Get the tail of the ChunkedArray

source

pub fn prune_empty_chunks(&mut self)

Remove empty chunks.

source§

impl ChunkedArray<StringType>

source

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

Convert an StringChunked to a Series of DataType::Decimal. Scale needed for the decimal type are inferred. Parsing is not strict.
Scale inference assumes that all tested strings are well-formed numbers, and may produce unexpected results for scale if this is not the case.

If the decimal precision and scale are already known, consider using the cast method.

source§

impl<T> ChunkedArray<T>

source

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.

source§

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

source

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

source§

impl ChunkedArray<FixedSizeListType>

source

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

Available on crate feature dtype-array only.
source§

impl ChunkedArray<ListType>

source

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

source§

impl ChunkedArray<UInt32Type>

source

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

source§

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

source

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

Get a mask of the null values.

source

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

Get a mask of the valid values.

source§

impl<T> ChunkedArray<T>

source

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

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

source§

impl ChunkedArray<BinaryType>

source

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

§Safety

String is not validated

source§

impl ChunkedArray<StringType>

source§

impl ChunkedArray<BooleanType>

source

pub fn any(&self) -> bool

Returns whether any of the values in the column are true.

Null values are ignored.

source

pub fn all(&self) -> bool

Returns whether all values in the array are true.

Null values are ignored.

source

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

Returns whether any of the values in the column are true.

The output is unknown (None) if the array contains any null values and no true values.

source

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

Returns whether all values in the column are true.

The output is unknown (None) if the array contains any null values and no false values.

source§

impl<T> ChunkedArray<T>

source

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

source

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

source

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

source

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

source

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

Convert missing values to NaN values.

source§

impl<T> ChunkedArray<T>

source

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

source§

impl ChunkedArray<ListType>

source

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

source

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

source§

impl ChunkedArray<StringType>

source

pub fn par_iter_indexed(&self) -> impl IndexedParallelIterator

source

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

source§

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

source

pub fn iter(&self) -> impl PolarsIterator

source§

impl<T> ChunkedArray<T>

source

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

source§

impl ChunkedArray<ListType>

source

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

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

source§

impl ChunkedArray<FixedSizeListType>

source

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

This is an iterator over a ListChunked that save allocations. A Series is: 1. Arc<ChunkedArray> 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.

source

pub fn amortized_iter_with_name( &self, name: &str ) -> AmortizedListIter<'_, impl Iterator<Item = Option<Box<dyn Array>>>>

source

pub fn try_apply_amortized_to_list<'a, F>( &'a self, f: F ) -> Result<ChunkedArray<ListType>, PolarsError>

source

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

Apply a closure F to each array.

§Safety

Return series of F must has the same dtype and number of elements as input.

source

pub unsafe fn try_apply_amortized_same_type<'a, F>( &'a self, f: F ) -> Result<ChunkedArray<FixedSizeListType>, PolarsError>

Try apply a closure F to each array.

§Safety

Return series of F must has the same dtype and number of elements as input if it is Ok.

source

pub unsafe fn zip_and_apply_amortized_same_type<'a, T, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> ChunkedArray<FixedSizeListType>

Zip with a ChunkedArray then apply a binary function F elementwise.

§Safety
source

pub fn apply_amortized_generic<'a, F, K, V>(&'a self, f: F) -> ChunkedArray<V>

Apply a closure F elementwise.

source

pub fn try_apply_amortized_generic<'a, F, K, V>( &'a self, f: F ) -> Result<ChunkedArray<V>, PolarsError>

Try apply a closure F elementwise.

source

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

source§

impl ChunkedArray<FixedSizeListType>

source

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the fixed size list.

source

pub fn width(&self) -> usize

source

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

§Safety

The caller must ensure that the logical type given fits the physical type of the array.

source

pub fn get_inner(&self) -> Series

Get the inner values as Series

source

pub fn apply_to_inner( &self, func: &dyn Fn(Series) -> Result<Series, PolarsError> ) -> Result<ChunkedArray<FixedSizeListType>, PolarsError>

Ignore the list indices and apply func to the inner type as Series.

source§

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

source

pub fn to_bytes_hashes<'a>( &'a self, multithreaded: bool, hb: RandomState ) -> Vec<Vec<BytesHash<'a>>>

source§

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

source

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

source

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

source

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

source

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

source

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

Create a new ChunkedArray from existing chunks.

§Safety

The Arrow datatype of all chunks must match the PolarsDataType T.

source

pub unsafe fn with_chunks(&self, chunks: Vec<Box<dyn Array>>) -> ChunkedArray<T>

§Safety

The Arrow datatype of all chunks must match the PolarsDataType T.

source

pub unsafe fn from_chunks_and_dtype( name: &str, chunks: Vec<Box<dyn Array>>, dtype: DataType ) -> ChunkedArray<T>

Create a new ChunkedArray from existing chunks.

§Safety

The Arrow datatype of all chunks must match the PolarsDataType T.

source

pub fn full_null_like(ca: &ChunkedArray<T>, length: usize) -> ChunkedArray<T>

source§

impl<T> ChunkedArray<T>

source

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

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

source

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

Create a new ChunkedArray from a Vec and a validity mask.

source

pub unsafe fn mmap_slice( name: &str, values: &[<T as PolarsNumericType>::Native] ) -> ChunkedArray<T>

Create a temporary ChunkedArray from a slice.

§Safety

The lifetime will be bound to the lifetime of the slice. This will not be checked by the borrowchecker.

source§

impl ChunkedArray<BooleanType>

source

pub unsafe fn mmap_slice( name: &str, values: &[u8], offset: usize, len: usize ) -> ChunkedArray<BooleanType>

Create a temporary ChunkedArray from a slice.

§Safety

The lifetime will be bound to the lifetime of the slice. This will not be checked by the borrowchecker.

source§

impl ChunkedArray<ListType>

source

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

This is an iterator over a ListChunked that save allocations. A Series is: 1. Arc<ChunkedArray> 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.

§Safety

The lifetime of UnstableSeries is bound to the iterator. Keeping it alive longer than the iterator is UB.

source

pub unsafe fn amortized_iter_with_name( &self, name: &str ) -> AmortizedListIter<'_, impl Iterator<Item = Option<Box<dyn Array>>>>

§Safety

The lifetime of UnstableSeries is bound to the iterator. Keeping it alive longer than the iterator is UB.

source

pub fn apply_amortized_generic<'a, F, K, V>(&'a self, f: F) -> ChunkedArray<V>

Apply a closure F elementwise.

source

pub fn try_apply_amortized_generic<'a, F, K, V>( &'a self, f: F ) -> Result<ChunkedArray<V>, PolarsError>

source

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

source

pub fn zip_and_apply_amortized<'a, T, I, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> ChunkedArray<ListType>
where T: PolarsDataType, &'a ChunkedArray<T>: IntoIterator<IntoIter = I>, I: TrustedLen<Item = Option<<T as PolarsDataType>::Physical<'a>>>, F: FnMut(Option<UnstableSeries<'a>>, Option<<T as PolarsDataType>::Physical<'a>>) -> Option<Series>,

Zip with a ChunkedArray then apply a binary function F elementwise.

source

pub fn binary_zip_and_apply_amortized<'a, T, U, F>( &'a self, ca1: &'a ChunkedArray<T>, ca2: &'a ChunkedArray<U>, f: F ) -> ChunkedArray<ListType>

source

pub fn try_zip_and_apply_amortized<'a, T, I, F>( &'a self, ca: &'a ChunkedArray<T>, f: F ) -> Result<ChunkedArray<ListType>, PolarsError>
where T: PolarsDataType, &'a ChunkedArray<T>: IntoIterator<IntoIter = I>, I: TrustedLen<Item = Option<<T as PolarsDataType>::Physical<'a>>>, F: FnMut(Option<UnstableSeries<'a>>, Option<<T as PolarsDataType>::Physical<'a>>) -> Result<Option<Series>, PolarsError>,

source

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

Apply a closure F elementwise.

source

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

source§

impl ChunkedArray<ListType>

source

pub fn inner_dtype(&self) -> DataType

Get the inner data type of the list.

source

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

source

pub fn set_fast_explode(&mut self)

source

pub fn _can_fast_explode(&self) -> bool

source

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

Set the logical type of the ListChunked.

§Safety

The caller must ensure that the logical type given fits the physical type of the array.

source

pub fn get_inner(&self) -> Series

Get the inner values as Series, ignoring the list offsets.

source

pub fn apply_to_inner( &self, func: &dyn Fn(Series) -> Result<Series, PolarsError> ) -> Result<ChunkedArray<ListType>, PolarsError>

Ignore the list indices and apply func to the inner type as Series.

source§

impl ChunkedArray<Int32Type>

source§

impl ChunkedArray<Int64Type>

source§

impl ChunkedArray<Int128Type>

source§

impl ChunkedArray<Int64Type>

source§

impl ChunkedArray<Int64Type>

source§

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

source

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

source

pub fn new_from_vec_and_validity( name: &str, v: Vec<T>, validity: Bitmap ) -> ChunkedArray<ObjectType<T>>

source

pub fn new_empty(name: &str) -> ChunkedArray<ObjectType<T>>

source§

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

source

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

source

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.

source§

impl<T> ChunkedArray<T>

source

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

source§

impl<T> ChunkedArray<T>

source

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.

source

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.

source§

impl<T> ChunkedArray<T>

source

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.

source

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

Create ChunkedArray with samples from a Standard Normal distribution.

source

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

Create ChunkedArray with samples from a Uniform distribution.

source§

impl ChunkedArray<BooleanType>

source

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

Create ChunkedArray with samples from a Bernoulli distribution.

source§

impl<T> ChunkedArray<T>

source

pub fn to_vec(&self) -> Vec<Option<<T as PolarsNumericType>::Native>>

Convert to a Vec of Option<T::Native>.

source

pub fn to_vec_null_aware( &self ) -> Either<Vec<<T as PolarsNumericType>::Native>, Vec<Option<<T as PolarsNumericType>::Native>>>

Convert to a Vec but don’t return Option<T::Native> if there are no null values

source§

impl ChunkedArray<FixedSizeListType>

source

pub unsafe fn from_iter_and_args<I>( iter: I, width: usize, capacity: usize, inner_dtype: Option<DataType>, name: &str ) -> ChunkedArray<FixedSizeListType>
where I: IntoIterator<Item = Option<Box<dyn Array>>>,

Available on crate feature dtype-array only.
§Safety

The caller must ensure that the underlying Arrays match the given datatype. That means the logical map should map to the physical type.

source§

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

source

pub fn unset_fast_explode_list(&mut self)

source

pub fn get_flags(&self) -> Settings

source

pub fn is_sorted_flag(&self) -> IsSorted

source

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

Set the ‘sorted’ bit meta info.

source

pub fn with_sorted_flag(&self, sorted: IsSorted) -> ChunkedArray<T>

Set the ‘sorted’ bit meta info.

source

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

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

source

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

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

source

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

Get the buffer of bits representing null values

source

pub fn has_validity(&self) -> bool

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

source

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit its length.

source

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

source

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

Series to ChunkedArray<T>

source

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

Unique id representing the number of chunks

source

pub fn chunks(&self) -> &Vec<Box<dyn Array>>

A reference to the chunks

source

pub unsafe fn chunks_mut(&mut self) -> &mut Vec<Box<dyn Array>>

A mutable reference to the chunks

§Safety

The caller must ensure to not change the DataType or length of any of the chunks. And the null_count remains correct.

source

pub fn is_optimal_aligned(&self) -> bool

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

source

pub fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

source

pub fn name(&self) -> &str

Name of the ChunkedArray.

source

pub fn ref_field(&self) -> &Field

Get a reference to the field.

source

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

Rename this ChunkedArray.

source

pub fn with_name(self, name: &str) -> ChunkedArray<T>

Return this ChunkedArray with a new name.

source§

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

source

pub fn get(&self, idx: usize) -> Option<<T as PolarsDataType>::Physical<'_>>

Get a single value from this ChunkedArray. If the return values is None this indicates a NULL value.

§Panics

This function will panic if idx is out of bounds.

source

pub unsafe fn get_unchecked( &self, idx: usize ) -> Option<<T as PolarsDataType>::Physical<'_>>

Get a single value from this ChunkedArray. If the return values is None this indicates a NULL value.

§Safety

It is the callers responsibility that the idx < self.len().

source

pub unsafe fn value_unchecked( &self, idx: usize ) -> <T as PolarsDataType>::Physical<'_>

Get a single value from this ChunkedArray. Null values are ignored and the returned value could be garbage if it was masked out by NULL. Note that the value always is initialized.

§Safety

It is the callers responsibility that the idx < self.len().

source

pub fn last(&self) -> Option<<T as PolarsDataType>::Physical<'_>>

source§

impl ChunkedArray<ListType>

source

pub fn get_as_series(&self, idx: usize) -> Option<Series>

source§

impl ChunkedArray<FixedSizeListType>

source

pub fn get_as_series(&self, idx: usize) -> Option<Series>

Available on crate feature dtype-array only.
source§

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

source

pub fn layout(&self) -> ChunkedArrayLayout<'_, T>

source§

impl<T> ChunkedArray<T>

source

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

Contiguous slice

source

pub fn data_views(&self) -> impl 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

source

pub fn into_no_null_iter( &self ) -> impl Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen

source§

impl<T> ChunkedArray<T>

source

pub fn group_tuples_perfect( &self, max: usize, multithreaded: bool, group_capacity: usize ) -> GroupsProxy

source§

impl<T> ChunkedArray<T>

source

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

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

source§

impl<T> ChunkedArray<T>

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

source

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

Apply lhs - self

source

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

Apply lhs / self

source

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

Apply lhs % self

Trait Implementations§

source§

impl Add<&[u8]> for &ChunkedArray<BinaryType>

§

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.
source§

fn add(self, rhs: &[u8]) -> <&ChunkedArray<BinaryType> as Add<&[u8]>>::Output

Performs the + operation. Read more
source§

impl Add<&str> for &ChunkedArray<StringType>

§

type Output = ChunkedArray<StringType>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<T, N> Add<N> for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<T, N> Add<N> for ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for &ChunkedArray<BinaryType>

§

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for &ChunkedArray<BooleanType>

§

type Output = ChunkedArray<UInt32Type>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for &ChunkedArray<StringType>

§

type Output = ChunkedArray<StringType>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<T> Add for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for ChunkedArray<BinaryType>

§

type Output = ChunkedArray<BinaryType>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for ChunkedArray<BooleanType>

§

type Output = ChunkedArray<UInt32Type>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl Add for ChunkedArray<StringType>

§

type Output = ChunkedArray<StringType>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl<T> Add for ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the + operator.
source§

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

Performs the + operation. Read more
source§

impl AggList for ChunkedArray<BinaryType>

source§

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

Safety Read more
source§

impl AggList for ChunkedArray<BooleanType>

source§

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

Safety Read more
source§

impl AggList for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Safety Read more
source§

impl AggList for ChunkedArray<ListType>

source§

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

Safety Read more
source§

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

Available on crate feature object only.
source§

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

Safety Read more
source§

impl AggList for ChunkedArray<StringType>

source§

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

Safety Read more
source§

impl<T> AggList for ChunkedArray<T>

source§

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

Safety Read more
source§

impl<T> ArithmeticChunked for &ChunkedArray<T>

§

type Scalar = <T as PolarsNumericType>::Native

§

type Out = ChunkedArray<T>

§

type TrueDivOut = ChunkedArray<<<T as PolarsNumericType>::Native as NumericNative>::TrueDivPolarsType>

source§

fn wrapping_abs(self) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_neg(self) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_add( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mul( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_add_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mul_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn true_div( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn true_div_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn true_div_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn legacy_div( self, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn legacy_div_scalar( self, rhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn legacy_div_scalar_lhs( lhs: <&ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: &ChunkedArray<T> ) -> <&ChunkedArray<T> as ArithmeticChunked>::Out

source§

impl<T> ArithmeticChunked for ChunkedArray<T>

§

type Scalar = <T as PolarsNumericType>::Native

§

type Out = ChunkedArray<T>

§

type TrueDivOut = ChunkedArray<<<T as PolarsNumericType>::Native as NumericNative>::TrueDivPolarsType>

source§

fn wrapping_abs(self) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_neg(self) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_add( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mul( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_add_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_sub_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mul_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_floor_div_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_trunc_div_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn wrapping_mod_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn true_div( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn true_div_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn true_div_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::TrueDivOut

source§

fn legacy_div( self, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn legacy_div_scalar( self, rhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

fn legacy_div_scalar_lhs( lhs: <ChunkedArray<T> as ArithmeticChunked>::Scalar, rhs: ChunkedArray<T> ) -> <ChunkedArray<T> as ArithmeticChunked>::Out

source§

impl ArrayNameSpace for ChunkedArray<FixedSizeListType>

source§

impl AsArray for ChunkedArray<FixedSizeListType>

source§

impl AsBinary for ChunkedArray<BinaryType>

source§

impl AsList for ChunkedArray<ListType>

source§

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

source§

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

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

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

source§

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

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

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

source§

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

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

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

source§

impl AsString for ChunkedArray<StringType>

source§

impl AsString for ChunkedArray<StringType>

source§

impl BinaryNameSpaceImpl for ChunkedArray<BinaryType>

source§

fn contains(&self, lit: &[u8]) -> ChunkedArray<BooleanType>

Check if binary contains given literal
source§

fn contains_chunked( &self, lit: &ChunkedArray<BinaryType> ) -> ChunkedArray<BooleanType>

source§

fn ends_with(&self, sub: &[u8]) -> ChunkedArray<BooleanType>

Check if strings ends with a substring
source§

fn starts_with(&self, sub: &[u8]) -> ChunkedArray<BooleanType>

Check if strings starts with a substring
source§

fn starts_with_chunked( &self, prefix: &ChunkedArray<BinaryType> ) -> ChunkedArray<BooleanType>

source§

fn ends_with_chunked( &self, suffix: &ChunkedArray<BinaryType> ) -> ChunkedArray<BooleanType>

source§

impl BitAnd for &ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl<T> BitAnd for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl BitAnd for ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.
source§

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

Performs the & operation. Read more
source§

impl BitOr for &ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl<T> BitOr for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl BitOr for ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.
source§

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

Performs the | operation. Read more
source§

impl BitXor for &ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<T> BitXor for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl BitXor for ChunkedArray<BooleanType>

§

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.
source§

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

Performs the ^ operation. Read more
source§

impl<T> ChunkAgg<<T as PolarsNumericType>::Native> for ChunkedArray<T>
where PrimitiveArray<<T as PolarsNumericType>::Native>: for<'a> MinMaxKernel<Scalar<'a> = <T as PolarsNumericType>::Native>, <<T as PolarsNumericType>::Native as Simd>::Simd: Add<Output = <<T as PolarsNumericType>::Native as Simd>::Simd> + Sum<<T as PolarsNumericType>::Native>, T: PolarsNumericType,

source§

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

Aggregate the sum of the ChunkedArray. Returns None if not implemented for T. If the array is empty, 0 is returned
source§

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

source§

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

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

source§

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

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

impl ChunkAggSeries for ChunkedArray<BinaryType>

source§

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

impl ChunkAggSeries for ChunkedArray<BooleanType>

source§

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

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

Available on crate feature object only.
source§

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

impl ChunkAggSeries for ChunkedArray<StringType>

source§

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

impl<T> ChunkAggSeries for ChunkedArray<T>
where PrimitiveArray<<T as PolarsNumericType>::Native>: for<'a> MinMaxKernel<Scalar<'a> = <T as PolarsNumericType>::Native>, <<T as PolarsNumericType>::Native as Simd>::Simd: Add<Output = <<T as PolarsNumericType>::Native as Simd>::Simd> + Sum<<T as PolarsNumericType>::Native>, T: PolarsNumericType, ChunkedArray<T>: IntoSeries,

source§

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

impl ChunkAnyValue for ChunkedArray<BinaryOffsetType>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl ChunkAnyValue for ChunkedArray<BinaryType>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl ChunkAnyValue for ChunkedArray<BooleanType>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl ChunkAnyValue for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl ChunkAnyValue for ChunkedArray<ListType>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

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

Available on crate feature object only.
source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl ChunkAnyValue for ChunkedArray<StringType>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl<T> ChunkAnyValue for ChunkedArray<T>

source§

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 Read more
source§

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

Get a single value. Beware this is slow.
source§

impl<'a> ChunkApply<'a, &'a [u8]> for ChunkedArray<BinaryType>

§

type FuncRet = Cow<'a, [u8]>

source§

fn apply_values<F>(&'a self, f: F) -> ChunkedArray<BinaryType>
where F: Fn(&'a [u8]) -> Cow<'a, [u8]> + Copy,

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

fn apply<F>(&'a self, f: F) -> ChunkedArray<BinaryType>
where F: Fn(Option<&'a [u8]>) -> Option<Cow<'a, [u8]>> + Copy,

Apply a closure elementwise including null values.
source§

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

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

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

Available on crate feature object only.
§

type FuncRet = T

source§

fn apply_values<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. Read more
source§

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

Apply a closure elementwise including null values.
source§

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

impl<'a> ChunkApply<'a, &'a str> for ChunkedArray<StringType>

§

type FuncRet = Cow<'a, str>

source§

fn apply_values<F>(&'a self, f: F) -> ChunkedArray<StringType>
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. Read more
source§

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

Apply a closure elementwise including null values.
source§

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

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

§

type FuncRet = <T as PolarsNumericType>::Native

source§

fn apply_values<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. Read more
source§

fn apply<F>(&'a self, f: F) -> ChunkedArray<T>

Apply a closure elementwise including null values.
source§

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

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

source§

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

Apply a closure F elementwise.

§

type FuncRet = Series

source§

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

Apply a closure elementwise including null values.
source§

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

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

§

type FuncRet = bool

source§

fn apply_values<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. Read more
source§

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

Apply a closure elementwise including null values.
source§

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

impl ChunkApplyKernel<BinaryViewArrayGeneric<[u8]>> for ChunkedArray<BinaryType>

source§

fn apply_kernel( &self, f: &dyn Fn(&BinaryViewArrayGeneric<[u8]>) -> Box<dyn Array> ) -> ChunkedArray<BinaryType>

Apply kernel and return result as a new ChunkedArray.
source§

fn apply_kernel_cast<S>( &self, f: &dyn Fn(&BinaryViewArrayGeneric<[u8]>) -> Box<dyn Array> ) -> ChunkedArray<S>
where S: PolarsDataType,

Apply a kernel that outputs an array of different type.
source§

impl ChunkApplyKernel<BinaryViewArrayGeneric<str>> for ChunkedArray<StringType>

source§

fn apply_kernel( &self, f: &dyn Fn(&BinaryViewArrayGeneric<str>) -> Box<dyn Array> ) -> ChunkedArray<StringType>

Apply kernel and return result as a new ChunkedArray.
source§

fn apply_kernel_cast<S>( &self, f: &dyn Fn(&BinaryViewArrayGeneric<str>) -> Box<dyn Array> ) -> ChunkedArray<S>
where S: PolarsDataType,

Apply a kernel that outputs an array of different type.
source§

impl ChunkApplyKernel<BooleanArray> for ChunkedArray<BooleanType>

source§

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

Apply kernel and return result as a new ChunkedArray.
source§

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

Apply a kernel that outputs an array of different type.
source§

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

source§

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

Apply kernel and return result as a new ChunkedArray.
source§

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

Apply a kernel that outputs an array of different type.
source§

impl ChunkCast for ChunkedArray<BinaryOffsetType>

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCast for ChunkedArray<BinaryType>

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCast for ChunkedArray<BooleanType>

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCast for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.

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

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCast for ChunkedArray<ListType>

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

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCast for ChunkedArray<StringType>

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl<T> ChunkCast for ChunkedArray<T>

source§

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

source§

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

Does not check if the cast is a valid one and may over/underflow Read more
source§

impl ChunkCompare<&[u8]> for ChunkedArray<BinaryType>

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

fn equal_missing(&self, rhs: &[u8]) -> ChunkedArray<BooleanType>

Check for equality where None == None.
source§

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

Check for inequality.
source§

fn not_equal_missing(&self, rhs: &[u8]) -> ChunkedArray<BooleanType>

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

impl ChunkCompare<&ChunkedArray<BinaryType>> for ChunkedArray<BinaryType>

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

impl ChunkCompare<&ChunkedArray<FixedSizeListType>> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

fn not_equal_missing( &self, rhs: &ChunkedArray<FixedSizeListType> ) -> <ChunkedArray<FixedSizeListType> as ChunkCompare<&ChunkedArray<FixedSizeListType>>>::Item

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

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

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

impl ChunkCompare<&ChunkedArray<StringType>> for CategoricalChunked

§

type Item = Result<ChunkedArray<BooleanType>, PolarsError>

source§

fn equal( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Check for equality.
source§

fn equal_missing( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Check for equality where None == None.
source§

fn not_equal( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Check for inequality.
source§

fn not_equal_missing( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Check for inequality where None == None.
source§

fn gt( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Greater than comparison.
source§

fn gt_eq( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Greater than or equal comparison.
source§

fn lt( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Less than comparison.
source§

fn lt_eq( &self, rhs: &ChunkedArray<StringType> ) -> <CategoricalChunked as ChunkCompare<&ChunkedArray<StringType>>>::Item

Less than or equal comparison
source§

impl ChunkCompare<&ChunkedArray<StringType>> for ChunkedArray<StringType>

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

impl<T> ChunkCompare<&ChunkedArray<T>> for ChunkedArray<T>
where T: PolarsNumericType, <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native>,

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

impl ChunkCompare<&str> for ChunkedArray<StringType>

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

impl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T>
where T: PolarsNumericType, Rhs: ToPrimitive, <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native>,

§

type Item = ChunkedArray<BooleanType>

source§

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

Check for equality.
source§

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

Check for equality where None == None.
source§

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

Check for inequality.
source§

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

Check for inequality where None == None.
source§

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

Greater than comparison.
source§

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

Greater than or equal comparison.
source§

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

Less than comparison.
source§

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

Less than or equal comparison
source§

impl ChunkExpandAtIndex<BinaryOffsetType> for ChunkedArray<BinaryOffsetType>

source§

fn new_from_index( &self, index: usize, length: usize ) -> ChunkedArray<BinaryOffsetType>

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExpandAtIndex<BinaryType> for ChunkedArray<BinaryType>

source§

fn new_from_index( &self, index: usize, length: usize ) -> ChunkedArray<BinaryType>

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExpandAtIndex<BooleanType> for ChunkedArray<BooleanType>

source§

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

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExpandAtIndex<FixedSizeListType> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

fn new_from_index( &self, index: usize, length: usize ) -> ChunkedArray<FixedSizeListType>

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExpandAtIndex<ListType> for ChunkedArray<ListType>

source§

fn new_from_index(&self, index: usize, length: usize) -> ChunkedArray<ListType>

Create a new ChunkedArray filled with values at that index.
source§

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

Available on crate feature object only.
source§

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

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExpandAtIndex<StringType> for ChunkedArray<StringType>

source§

fn new_from_index( &self, index: usize, length: usize ) -> ChunkedArray<StringType>

Create a new ChunkedArray filled with values at that index.
source§

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

source§

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

Create a new ChunkedArray filled with values at that index.
source§

impl ChunkExplode for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

fn offsets(&self) -> Result<OffsetsBuffer<i64>, PolarsError>

source§

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

source§

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

source§

impl ChunkExplode for ChunkedArray<ListType>

source§

fn offsets(&self) -> Result<OffsetsBuffer<i64>, PolarsError>

source§

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

source§

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

source§

impl ChunkExplode for ChunkedArray<StringType>

source§

fn offsets(&self) -> Result<OffsetsBuffer<i64>, PolarsError>

source§

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

source§

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

source§

impl ChunkFillNullValue<&[u8]> for ChunkedArray<BinaryType>

source§

fn fill_null_with_values( &self, value: &[u8] ) -> Result<ChunkedArray<BinaryType>, PolarsError>

Replace None values with a give value T.
source§

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

source§

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

Replace None values with a give value T.
source§

impl ChunkFillNullValue<bool> for ChunkedArray<BooleanType>

source§

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

Replace None values with a give value T.
source§

impl ChunkFilter<BinaryOffsetType> for ChunkedArray<BinaryOffsetType>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl ChunkFilter<BinaryType> for ChunkedArray<BinaryType>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl ChunkFilter<BooleanType> for ChunkedArray<BooleanType>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl ChunkFilter<FixedSizeListType> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl ChunkFilter<ListType> for ChunkedArray<ListType>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

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

Available on crate feature object only.
source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl ChunkFilter<StringType> for ChunkedArray<StringType>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl<T> ChunkFilter<T> for ChunkedArray<T>

source§

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

Filter values in the ChunkedArray with a boolean mask. Read more
source§

impl<'a> ChunkFull<&'a [u8]> for ChunkedArray<BinaryOffsetType>

source§

fn full( name: &str, value: &'a [u8], length: usize ) -> ChunkedArray<BinaryOffsetType>

Create a ChunkedArray with a single value.
source§

impl<'a> ChunkFull<&'a [u8]> for ChunkedArray<BinaryType>

source§

fn full(name: &str, value: &'a [u8], length: usize) -> ChunkedArray<BinaryType>

Create a ChunkedArray with a single value.
source§

impl ChunkFull<&Series> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Create a ChunkedArray with a single value.
source§

impl ChunkFull<&Series> for ChunkedArray<ListType>

source§

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

Create a ChunkedArray with a single value.
source§

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

source§

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

Create a ChunkedArray with a single value.
source§

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

source§

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

Create a ChunkedArray with a single value.
source§

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

Available on crate feature object only.
source§

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

Create a ChunkedArray with a single value.
source§

impl ChunkFull<bool> for ChunkedArray<BooleanType>

source§

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

Create a ChunkedArray with a single value.
source§

impl ChunkFullNull for ChunkedArray<BinaryOffsetType>

source§

impl ChunkFullNull for ChunkedArray<BinaryType>

source§

impl ChunkFullNull for ChunkedArray<BooleanType>

source§

impl ChunkFullNull for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

impl ChunkFullNull for ChunkedArray<ListType>

source§

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

Available on crate feature object only.
source§

impl ChunkFullNull for ChunkedArray<StringType>

source§

impl<T> ChunkFullNull for ChunkedArray<T>

source§

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

source§

impl ChunkQuantile<Series> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

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

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

impl ChunkQuantile<Series> for ChunkedArray<ListType>

source§

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

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

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

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

Available on crate feature object only.
source§

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

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

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

impl ChunkQuantile<String> for ChunkedArray<StringType>

source§

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

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

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

impl ChunkQuantile<bool> for ChunkedArray<BooleanType>

source§

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

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

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

impl ChunkQuantile<f32> for ChunkedArray<Float32Type>

source§

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

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

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

impl ChunkQuantile<f64> for ChunkedArray<Float64Type>

source§

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

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

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

impl<T> ChunkQuantile<f64> for ChunkedArray<T>

source§

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

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

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

impl ChunkReverse for ChunkedArray<BinaryOffsetType>

source§

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

Return a reversed version of this array.
source§

impl ChunkReverse for ChunkedArray<BinaryType>

source§

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

Return a reversed version of this array.
source§

impl ChunkReverse for ChunkedArray<BooleanType>

source§

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

Return a reversed version of this array.
source§

impl ChunkReverse for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Return a reversed version of this array.
source§

impl ChunkReverse for ChunkedArray<ListType>

source§

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

Return a reversed version of this array.
source§

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

Available on crate feature object only.
source§

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

Return a reversed version of this array.
source§

impl ChunkReverse for ChunkedArray<StringType>

source§

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

Return a reversed version of this array.
source§

impl<T> ChunkReverse for ChunkedArray<T>

source§

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

Return a reversed version of this array.
source§

impl<T> ChunkRollApply for ChunkedArray<T>

source§

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

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

source§

impl<'a> ChunkSet<'a, &'a [u8], Vec<u8>> for ChunkedArray<BinaryType>

source§

fn scatter_single<I>( &'a self, idx: I, opt_value: Option<&'a [u8]> ) -> Result<ChunkedArray<BinaryType>, PolarsError>

Set the values at indexes idx to some optional value Option<T>. Read more
source§

fn scatter_with<I, F>( &'a self, idx: I, f: F ) -> Result<ChunkedArray<BinaryType>, PolarsError>
where I: IntoIterator<Item = u32>, ChunkedArray<BinaryType>: Sized, F: Fn(Option<&'a [u8]>) -> Option<Vec<u8>>,

Set the values at indexes idx by applying a closure to these values. Read more
source§

fn set( &'a self, mask: &ChunkedArray<BooleanType>, value: Option<&'a [u8]> ) -> Result<ChunkedArray<BinaryType>, PolarsError>

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

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

source§

fn scatter_single<I>( &'a self, idx: I, opt_value: Option<&'a str> ) -> Result<ChunkedArray<StringType>, PolarsError>

Set the values at indexes idx to some optional value Option<T>. Read more
source§

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

Set the values at indexes idx by applying a closure to these values. Read more
source§

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

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

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

source§

fn scatter_single<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>. Read more
source§

fn scatter_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. Read more
source§

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>. Read more
source§

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

source§

fn scatter_single<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>. Read more
source§

fn scatter_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. Read more
source§

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>. Read more
source§

impl ChunkShift<BinaryOffsetType> for ChunkedArray<BinaryOffsetType>

source§

impl ChunkShift<BinaryType> for ChunkedArray<BinaryType>

source§

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

source§

impl ChunkShift<BooleanType> for ChunkedArray<BooleanType>

source§

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

source§

impl ChunkShift<FixedSizeListType> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

impl ChunkShift<ListType> for ChunkedArray<ListType>

source§

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

source§

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

Available on crate feature object only.
source§

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

source§

impl ChunkShift<StringType> for ChunkedArray<StringType>

source§

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

source§

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

source§

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

source§

impl ChunkShiftFill<BinaryOffsetType, Option<&[u8]>> for ChunkedArray<BinaryOffsetType>

source§

fn shift_and_fill( &self, periods: i64, fill_value: Option<&[u8]> ) -> ChunkedArray<BinaryOffsetType>

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

impl ChunkShiftFill<BinaryType, Option<&[u8]>> for ChunkedArray<BinaryType>

source§

fn shift_and_fill( &self, periods: i64, fill_value: Option<&[u8]> ) -> ChunkedArray<BinaryType>

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

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

source§

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

impl ChunkShiftFill<FixedSizeListType, Option<&Series>> for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

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

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

source§

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

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

Available on crate feature object only.
source§

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

impl ChunkShiftFill<StringType, Option<&str>> for ChunkedArray<StringType>

source§

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

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

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

source§

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

impl ChunkSort<BinaryOffsetType> for ChunkedArray<BinaryOffsetType>

source§

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> 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.

source§

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

source§

fn sort(&self, descending: bool) -> ChunkedArray<BinaryOffsetType>

Returned a sorted ChunkedArray.
source§

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

Retrieve the indexes needed to sort this array.
source§

impl ChunkSort<BinaryType> for ChunkedArray<BinaryType>

source§

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

source§

fn sort(&self, descending: bool) -> ChunkedArray<BinaryType>

Returned a sorted ChunkedArray.
source§

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

Retrieve the indexes needed to sort this array.
source§

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

impl ChunkSort<BooleanType> for ChunkedArray<BooleanType>

source§

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

source§

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

Returned a sorted ChunkedArray.
source§

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

Retrieve the indexes needed to sort this array.
source§

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

impl ChunkSort<StringType> for ChunkedArray<StringType>

source§

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> 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.

source§

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

source§

fn sort(&self, descending: bool) -> ChunkedArray<StringType>

Returned a sorted ChunkedArray.
source§

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

Retrieve the indexes needed to sort this array.
source§

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

source§

fn arg_sort_multiple( &self, by: &[Series], options: &SortMultipleOptions ) -> 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

source§

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

source§

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

Returned a sorted ChunkedArray.
source§

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

Retrieve the indexes needed to sort this array.
source§

impl<T> ChunkTake<ChunkedArray<UInt32Type>> for ChunkedArray<T>

source§

fn take( &self, indices: &ChunkedArray<UInt32Type> ) -> Result<ChunkedArray<T>, PolarsError>

Gather values from ChunkedArray by index.

source§

impl<T, I> ChunkTake<I> for ChunkedArray<T>

source§

fn take(&self, indices: &I) -> Result<ChunkedArray<T>, PolarsError>

Gather values from ChunkedArray by index.

source§

impl ChunkTakeUnchecked<ChunkedArray<UInt32Type>> for ChunkedArray<BinaryType>

source§

unsafe fn take_unchecked( &self, indices: &ChunkedArray<UInt32Type> ) -> ChunkedArray<BinaryType>

Gather values from ChunkedArray by index.

source§

impl ChunkTakeUnchecked<ChunkedArray<UInt32Type>> for ChunkedArray<StringType>

source§

unsafe fn take_unchecked( &self, indices: &ChunkedArray<UInt32Type> ) -> ChunkedArray<StringType>

Gather values from ChunkedArray by index. Read more
source§

impl<T> ChunkTakeUnchecked<ChunkedArray<UInt32Type>> for ChunkedArray<T>
where T: PolarsDataType + NotSpecialized,

source§

unsafe fn take_unchecked( &self, indices: &ChunkedArray<UInt32Type> ) -> ChunkedArray<T>

Gather values from ChunkedArray by index.

source§

impl<T, I> ChunkTakeUnchecked<I> for ChunkedArray<T>
where T: PolarsDataType, I: AsRef<[u32]> + ?Sized,

source§

unsafe fn take_unchecked(&self, indices: &I) -> ChunkedArray<T>

Gather values from ChunkedArray by index.

source§

impl ChunkUnique<BinaryType> for ChunkedArray<BinaryType>

source§

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

Get unique values of a ChunkedArray
source§

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

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

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

Number of unique values in the ChunkedArray
source§

impl ChunkUnique<BooleanType> for ChunkedArray<BooleanType>

source§

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

Get unique values of a ChunkedArray
source§

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

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

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

Number of unique values in the ChunkedArray
source§

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

Available on crate feature object only.
source§

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

Get unique values of a ChunkedArray
source§

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

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

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

Number of unique values in the ChunkedArray
source§

impl ChunkUnique<StringType> for ChunkedArray<StringType>

source§

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

Get unique values of a ChunkedArray
source§

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

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

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

Number of unique values in the ChunkedArray
source§

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

source§

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

Get unique values of a ChunkedArray
source§

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

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

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

Number of unique values in the ChunkedArray
source§

impl ChunkVar for ChunkedArray<BooleanType>

source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

impl ChunkVar for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

impl ChunkVar for ChunkedArray<ListType>

source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

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

Available on crate feature object only.
source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

impl ChunkVar for ChunkedArray<StringType>

source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

impl<T> ChunkVar for ChunkedArray<T>

source§

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

Compute the variance of this ChunkedArray/Series.
source§

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

Compute the standard deviation of this ChunkedArray/Series.
source§

impl<T> ChunkZip<T> for ChunkedArray<T>
where T: PolarsDataType, <T as PolarsDataType>::Array: for<'a> IfThenElseKernel<Scalar<'a> = <T as PolarsDataType>::Physical<'a>>, ChunkedArray<T>: ChunkExpandAtIndex<T>,

source§

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

impl<'a> ChunkedSet<&'a str> for &'a ChunkedArray<StringType>

source§

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

source§

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

source§

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

source§

impl ChunkedSet<bool> for &ChunkedArray<BooleanType>

source§

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

source§

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

source§

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

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for ChunkedArray<BinaryType>

source§

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

Formats the value using the given formatter. Read more
source§

impl Debug for ChunkedArray<BooleanType>

source§

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

Formats the value using the given formatter. Read more
source§

impl Debug for ChunkedArray<FixedSizeListType>

Available on crate feature dtype-array only.
source§

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

Formats the value using the given formatter. Read more
source§

impl Debug for ChunkedArray<ListType>

source§

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

Formats the value using the given formatter. Read more
source§

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

Available on crate feature object only.
source§

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

Formats the value using the given formatter. Read more
source§

impl Debug for ChunkedArray<StringType>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T> Debug for ChunkedArray<T>

source§

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

Formats the value using the given formatter. Read more
source§

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

source§

fn default() -> ChunkedArray<T>

Returns the “default value” for a type. Read more
source§

impl<T, N> Div<N> for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl<T, N> Div<N> for ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl<T> Div for &ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

impl<T> Div for ChunkedArray<T>

§

type Output = ChunkedArray<T>

The resulting type after applying the / operator.
source§

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

Performs the / operation. Read more
source§

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

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<<T as PolarsDataType>::Physical<'a>>>
where T: PolarsDataType,

source§

fn from( ca: &'a ChunkedArray<T> ) -> Vec<Option<<T as PolarsDataType>::Physical<'a>>>

Converts to this type from the input type.
source§

impl<T, A> From<A> for ChunkedArray<T>
where T: PolarsDataType<Array = A>, A: Array,

source§

fn from(arr: A) -> ChunkedArray<T>

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

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

Converts to this type from the input type.
source§

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

source§

fn from(ca: ChunkedArray<StringType>) -> Vec<Option<String>>

Converts to this type from the input type.
source§

impl<T> From<ChunkedArray<T>> for Series

source§

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

Converts to this type from the input type.
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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

FromIterator trait

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<Option<Box<dyn Array>>> for ChunkedArray<ListType>

source§

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

Creates a value from an iterator. Read more
source§

impl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<BinaryType>
where Ptr: AsRef<[u8]>,

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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

Available on crate feature object only.
source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

impl<Ptr> FromIterator<Ptr> for ChunkedArray<BinaryType>
where Ptr: PolarsAsRef<[u8]>,

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

Creates a value from an iterator. Read more
source§

impl FromIterator<bool> for ChunkedArray<BooleanType>

source§

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

Creates a value from an iterator. Read more
source§

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

source§

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

source§

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

source§

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

source§

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

source§

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. Read more
source§

impl<Ptr> FromParallelIterator<Option<Ptr>> for ChunkedArray<BinaryType>
where Ptr: AsRef<[u8]> + Send + Sync,

source§

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

Creates an instance of the collection from the parallel iterator par_iter. Read more
source§

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

source§

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

Creates an instance of the collection from the parallel iterator par_iter. Read more
source§

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

From trait

source§

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. Read more
source§

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

source§

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

Creates an instance of the collection from the parallel iterator par_iter. Read more
source§

impl<Ptr> FromParallelIterator<Ptr> for ChunkedArray<BinaryType>
where Ptr: PolarsAsRef<[u8]> + Send + Sync,

source§

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

Creates an instance of the collection from the parallel iterator par_iter. Read more
source§

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

source§

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

Creates an instance of the collection from the parallel iterator par_iter. Read more
source§

impl FromParallelIterator<bool> for ChunkedArray<BooleanType>

source§

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. Read more
source§

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

source§

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

source§

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<BinaryOffsetType>
where Ptr: AsRef<[u8]>,

source§

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<BinaryType>
where Ptr: AsRef<[u8]>,

source§

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

source§

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

source§

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

Available on crate feature object only.
source§

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