Type Alias StringChunked

pub type StringChunked = ChunkedArray<StringType>;

Aliased Type

struct StringChunked { /* private fields */ }

Implementations

impl ChunkedArray<StringType>

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

impl ChunkedArray<StringType>

pub fn par_iter_indexed(&self) -> impl IndexedParallelIterator

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

impl ChunkedArray<StringType>

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

where F: FnMut(&'a str) -> &'a str,

impl ChunkedArray<StringType>

pub unsafe fn apply_views<F>(&self, update_view: F) -> ChunkedArray<StringType>

where F: FnMut(View, &str) -> View + Copy,

Safety

Update the views. All invariants of the views apply.

impl ChunkedArray<StringType>

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.

impl<T> ChunkedArray<T>

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

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

impl<T> ChunkedArray<T>

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

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

impl<T> ChunkedArray<T>

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

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

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

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

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

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

Convert missing values to NaN values.

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

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

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

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

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

pub unsafe fn mmap_slice( name: PlSmallStr, 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.

impl<T> ChunkedArray<T>

where T: PolarsDataType,

pub fn with_chunk<A>(name: PlSmallStr, arr: A) -> ChunkedArray<T>

where A: Array, T: PolarsDataType<Array = A>,

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

where A: Array, T: PolarsDataType<Array = A>,

pub fn from_chunk_iter<I>(name: PlSmallStr, iter: I) -> ChunkedArray<T>

where I: IntoIterator, T: PolarsDataType<Array = <I as IntoIterator>::Item>, <I as IntoIterator>::Item: Array,

pub fn from_chunk_iter_like<I>(ca: &ChunkedArray<T>, iter: I) -> ChunkedArray<T>

where I: IntoIterator, T: PolarsDataType<Array = <I as IntoIterator>::Item>, <I as IntoIterator>::Item: Array,

pub fn try_from_chunk_iter<I, A, E>( name: PlSmallStr, iter: I, ) -> Result<ChunkedArray<T>, E>

where I: IntoIterator<Item = Result<A, E>>, T: PolarsDataType<Array = A>, A: Array,

pub unsafe fn from_chunks( name: PlSmallStr, 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.

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.

pub unsafe fn from_chunks_and_dtype( name: PlSmallStr, 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.

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

impl<T> ChunkedArray<T>

where T: PolarsDataType,

pub fn iter(&self) -> impl PolarsIterator

impl<T> ChunkedArray<T>

where T: PolarsDataType,

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

Series to ChunkedArray<T>

pub unsafe fn new_with_dims( field: Arc<Field>, chunks: Vec<Box<dyn Array>>, length: usize, null_count: usize, ) -> ChunkedArray<T>

Create a new ChunkedArray and explicitly set its length and null_count.

Safety

The length and null_count must be correct.

pub fn unset_fast_explode_list(&mut self)

pub fn set_fast_explode_list(&mut self, value: bool)

pub fn get_fast_explode_list(&self) -> bool

pub fn get_flags(&self) -> StatisticsFlags

pub fn is_sorted_flag(&self) -> IsSorted

pub fn retain_flags_from<U>( &mut self, from: &ChunkedArray<U>, retain_flags: StatisticsFlags, )

where U: PolarsDataType,

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

Set the ‘sorted’ bit meta info.

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

Set the ‘sorted’ bit meta info.

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

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

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

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

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

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

Get the buffer of bits representing null values

pub fn has_nulls(&self) -> bool

Return if any the chunks in this ChunkedArray have nulls.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of this array to fit its length.

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

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

Returns an iterator over the lengths of the chunks of the array.

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

A reference to the chunks

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.

pub fn is_optimal_aligned(&self) -> bool

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

pub fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

pub fn name(&self) -> &PlSmallStr

Name of the ChunkedArray.

pub fn ref_field(&self) -> &Field

Get a reference to the field.

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

Rename this ChunkedArray.

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

Return this ChunkedArray with a new name.

impl<T> ChunkedArray<T>

where T: PolarsDataType,

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.

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

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

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

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

impl<T> ChunkedArray<T>

where T: PolarsDataType,

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

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

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

Returns the values of the array as a contiguous slice.

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

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

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

pub fn to_ndarray( &self, ) -> Result<ArrayBase<ViewRepr<&<T as PolarsNumericType>::Native>, Dim<[usize; 1]>>, PolarsError>

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

impl<T> ChunkedArray<T>

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

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

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

See also extend for appends to the underlying memory

pub fn append_owned( &mut self, other: ChunkedArray<T>, ) -> Result<(), PolarsError>

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

See also extend for appends to the underlying memory

impl<T> ChunkedArray<T>

where T: PolarsDataType,

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

where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> K, <U as PolarsDataType>::Array: ArrayFromIterDtype<K> + ArrayFromIterDtype<Option<K>>,

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

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

where U: PolarsDataType, F: FnMut(<T as PolarsDataType>::Physical<'a>) -> Result<K, E>, <U as PolarsDataType>::Array: ArrayFromIter<K> + ArrayFromIter<Option<K>>,

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

pub fn apply_into_string_amortized<'a, F>( &'a self, f: F, ) -> ChunkedArray<StringType>

where F: FnMut(<T as PolarsDataType>::Physical<'a>, &mut String),

pub fn try_apply_into_string_amortized<'a, F, E>( &'a self, f: F, ) -> Result<ChunkedArray<StringType>, E>

where F: FnMut(<T as PolarsDataType>::Physical<'a>, &mut String) -> Result<(), E>,

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

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

where F: Fn(<S as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy, S: PolarsNumericType,

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

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.

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

pub fn apply_mut<F>(&mut self, f: F)

where F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,

impl<T> ChunkedArray<T>

where T: PolarsDataType,

pub fn len(&self) -> usize

Get the length of the ChunkedArray

pub fn null_count(&self) -> usize

Return the number of null values in the ChunkedArray.

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

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.

pub fn is_empty(&self) -> bool

Check if ChunkedArray is empty.

pub fn rechunk(&self) -> Cow<'_, ChunkedArray<T>>

Rechunks this ChunkedArray, returning a new Cow::Owned ChunkedArray if it was rechunked or simply a Cow::Borrowed of itself if it was already a single chunk.

pub fn rechunk_mut(&mut self)

Rechunks this ChunkedArray in-place.

pub fn rechunk_validity(&self) -> Option<Bitmap>

pub fn with_validities(&mut self, validities: &[Option<Bitmap>])

pub fn split_at(&self, offset: i64) -> (ChunkedArray<T>, ChunkedArray<T>)

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

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

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

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

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

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

where ChunkedArray<T>: Sized,

Take a view of top n elements

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

where ChunkedArray<T>: Sized,

Get the head of the ChunkedArray

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

where ChunkedArray<T>: Sized,

Get the tail of the ChunkedArray

pub fn prune_empty_chunks(&mut self)

Remove empty chunks.

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

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

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

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

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

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

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

impl<T> ChunkedArray<T>

where T: PolarsDataType,

pub fn for_each<'a, F>(&'a self, op: F)

where F: FnMut(Option<<T as PolarsDataType>::Physical<'a>>),

impl<T> ChunkedArray<T>

where T: PolarsDataType,

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

Get a mask of the null values.

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

Get a mask of the valid values.

impl<T> ChunkedArray<T>

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

pub fn rolling_map_float<F>( &self, window_size: usize, f: F, ) -> Result<ChunkedArray<T>, PolarsError>

where F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,

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

impl<T> ChunkedArray<T>

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

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

Sample n datapoints from this ChunkedArray.

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

Sample a fraction between 0.0-1.0 of this ChunkedArray.

impl<T> ChunkedArray<T>

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

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

Create ChunkedArray with samples from a Normal distribution.

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

Create ChunkedArray with samples from a Standard Normal distribution.

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

Create ChunkedArray with samples from a Uniform distribution.

impl<T> ChunkedArray<T>

where T: PolarsNumericType, Standard: Distribution<<T as PolarsNumericType>::Native>,

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

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

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

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

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

impl<T> ChunkedArray<T>

where T: PolarsIntegerType, <T as PolarsNumericType>::Native: ToPrimitive + FromPrimitive + Debug,

pub unsafe fn group_tuples_perfect( &self, num_groups: usize, multithreaded: bool, group_capacity: usize, ) -> GroupsType

Use the indexes as perfect groups.

Safety

This ChunkedArray must contain each value in [0..num_groups) at least once, and nothing outside this range.

impl<T> ChunkedArray<T>

where T: PolarsNumericType,

pub fn new_vec( name: PlSmallStr, 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.

impl<T> ChunkedArray<T>

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

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

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

where N: Num + NumCast,

Apply lhs - self

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

where N: Num + NumCast,

Apply lhs / self

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

where N: Num + NumCast,

Apply lhs % self

Trait Implementations

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

where T: PolarsNumericType, N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for ChunkedArray<StringType>

type Output = ChunkedArray<StringType>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Add for ChunkedArray<T>

where T: PolarsNumericType,

type Output = ChunkedArray<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AggList for ChunkedArray<StringType>

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

Safety

impl<T> AggList for ChunkedArray<T>

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

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

Safety

impl<T> ArithmeticChunked for ChunkedArray<T>

where T: PolarsNumericType,

type Scalar = <T as PolarsNumericType>::Native

type Out = ChunkedArray<T>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

where T: PolarsDataType,

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

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

impl<T> AsRefDataType for ChunkedArray<T>

where T: PolarsDataType,

fn as_ref_dtype(&self) -> &DataType

impl AsString for ChunkedArray<StringType>

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

impl AsString for ChunkedArray<StringType>

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

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

where T: PolarsNumericType, <T as PolarsNumericType>::Native: WrappingSum, PrimitiveArray<<T as PolarsNumericType>::Native>: for<'a> MinMaxKernel<Scalar<'a> = <T as PolarsNumericType>::Native>,

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

fn _sum_as_f64(&self) -> f64

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

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

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

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

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

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

impl ChunkAggSeries for ChunkedArray<StringType>

fn max_reduce(&self) -> Scalar

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

fn min_reduce(&self) -> Scalar

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

fn sum_reduce(&self) -> Scalar

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

fn prod_reduce(&self) -> Scalar

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

impl<T> ChunkAggSeries for ChunkedArray<T>

where T: PolarsNumericType, <T as PolarsNumericType>::Native: WrappingSum, PrimitiveArray<<T as PolarsNumericType>::Native>: for<'a> MinMaxKernel<Scalar<'a> = <T as PolarsNumericType>::Native>, ChunkedArray<T>: IntoSeries,

fn sum_reduce(&self) -> Scalar

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

fn max_reduce(&self) -> Scalar

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

fn min_reduce(&self) -> Scalar

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

fn prod_reduce(&self) -> Scalar

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

impl ChunkAnyValue for ChunkedArray<StringType>

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

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

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

Get a single value. Beware this is slow.

impl<T> ChunkAnyValue for ChunkedArray<T>

where T: PolarsNumericType,

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

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

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

Get a single value. Beware this is slow.

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

type FuncRet = Cow<'a, str>

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.

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.

fn apply_to_slice<F, T>(&'a self, f: F, slice: &mut [T])

where F: Fn(Option<&'a str>, &T) -> T,

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

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

where T: PolarsNumericType,

type FuncRet = <T as PolarsNumericType>::Native

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.

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

where F: Fn(Option<<T as PolarsNumericType>::Native>) -> Option<<T as PolarsNumericType>::Native> + Copy,

Apply a closure elementwise including null values.

fn apply_to_slice<F, V>(&'a self, f: F, slice: &mut [V])

where F: Fn(Option<<T as PolarsNumericType>::Native>, &V) -> V,

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

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

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

Apply kernel and return result as a new ChunkedArray.

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.

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

where T: PolarsNumericType,

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

Apply kernel and return result as a new ChunkedArray.

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

where S: PolarsDataType,

Apply a kernel that outputs an array of different type.

impl<T> ChunkApproxNUnique for ChunkedArray<T>

where T: PolarsDataType, <T as PolarsDataType>::Physical<'a>: for<'a> TotalHash + for<'a> TotalEq + for<'a> Copy + for<'a> ToTotalOrd, <Option<<T as PolarsDataType>::Physical<'a>> as ToTotalOrd>::TotalOrdItem: for<'a> Hash + for<'a> Eq,

fn approx_n_unique(&self) -> u32

impl ChunkCast for ChunkedArray<StringType>

fn cast_with_options( &self, dtype: &DataType, options: CastOptions, ) -> Result<Series, PolarsError>

Cast a ChunkedArray to DataType

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

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

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

Cast a ChunkedArray to DataType

impl<T> ChunkCast for ChunkedArray<T>

where T: PolarsNumericType,

fn cast_with_options( &self, dtype: &DataType, options: CastOptions, ) -> Result<Series, PolarsError>

Cast a ChunkedArray to DataType

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

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

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

Cast a ChunkedArray to DataType

impl ChunkCompareEq<&ChunkedArray<StringType>> for ChunkedArray<StringType>

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

impl<T> ChunkCompareEq<&ChunkedArray<T>> for ChunkedArray<T>

where <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native> + TotalEqKernel<Scalar = <T as PolarsNumericType>::Native>, T: PolarsNumericType,

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

impl ChunkCompareEq<&str> for ChunkedArray<StringType>

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

impl<T, Rhs> ChunkCompareEq<Rhs> for ChunkedArray<T>

where T: PolarsNumericType, Rhs: ToPrimitive, <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native> + TotalEqKernel<Scalar = <T as PolarsNumericType>::Native>,

type Item = ChunkedArray<BooleanType>

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

Check for equality.

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

Check for equality where None == None.

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

Check for inequality.

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

Check for inequality where None == None.

impl ChunkCompareIneq<&ChunkedArray<StringType>> for ChunkedArray<StringType>

type Item = ChunkedArray<BooleanType>

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl<T> ChunkCompareIneq<&ChunkedArray<T>> for ChunkedArray<T>

where <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native> + TotalEqKernel<Scalar = <T as PolarsNumericType>::Native>, T: PolarsNumericType,

type Item = ChunkedArray<BooleanType>

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

Less than comparison.

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

Less than or equal comparison

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

Greater than comparison.

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

Greater than or equal comparison.

impl ChunkCompareIneq<&str> for ChunkedArray<StringType>

type Item = ChunkedArray<BooleanType>

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl<T, Rhs> ChunkCompareIneq<Rhs> for ChunkedArray<T>

where T: PolarsNumericType, Rhs: ToPrimitive, <T as PolarsDataType>::Array: TotalOrdKernel<Scalar = <T as PolarsNumericType>::Native> + TotalEqKernel<Scalar = <T as PolarsNumericType>::Native>,

type Item = ChunkedArray<BooleanType>

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkExpandAtIndex<StringType> for ChunkedArray<StringType>

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

Create a new ChunkedArray filled with values at that index.

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

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

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

Create a new ChunkedArray filled with values at that index.

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

where T: PolarsNumericType,

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

Replace None values with a give value T.

impl ChunkFilter<StringType> for ChunkedArray<StringType>

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

Filter values in the ChunkedArray with a boolean mask.

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

where T: PolarsDataType<HasViews = FalseT, IsObject = FalseT>,

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

Filter values in the ChunkedArray with a boolean mask.

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

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

Create a ChunkedArray with a single value.

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

where T: PolarsNumericType,

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

Create a ChunkedArray with a single value.

impl ChunkFullNull for ChunkedArray<StringType>

fn full_null(name: PlSmallStr, length: usize) -> ChunkedArray<StringType>

impl<T> ChunkFullNull for ChunkedArray<T>

where T: PolarsNumericType,

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

impl ChunkQuantile<String> for ChunkedArray<StringType>

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

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

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

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

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

where T: PolarsIntegerType, <T as PolarsNumericType>::Native: TotalOrd,

fn quantile( &self, quantile: f64, method: QuantileMethod, ) -> Result<Option<f64>, PolarsError>

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

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

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

impl ChunkReverse for ChunkedArray<StringType>

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

Return a reversed version of this array.

impl<T> ChunkReverse for ChunkedArray<T>

where T: PolarsNumericType,

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

Return a reversed version of this array.

impl<T> ChunkRollApply for ChunkedArray<T>

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

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.

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

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

where I: IntoIterator<Item = u32>, ChunkedArray<StringType>: Sized,

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

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.

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

where ChunkedArray<StringType>: Sized,

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

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

where T: PolarsNumericType,

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

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.

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

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

impl ChunkShift<StringType> for ChunkedArray<StringType>

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

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

where T: PolarsNumericType,

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

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

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.

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

where T: PolarsNumericType,

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

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

impl ChunkSort<StringType> for ChunkedArray<StringType>

fn arg_sort_multiple( &self, by: &[Column], 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.

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

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

Returned a sorted ChunkedArray.

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

Retrieve the indexes needed to sort this array.

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

where T: PolarsNumericType,

fn arg_sort_multiple( &self, by: &[Column], 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

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

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

Returned a sorted ChunkedArray.

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

Retrieve the indexes needed to sort this array.

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

where T: PolarsDataType, ChunkedArray<T>: ChunkTakeUnchecked<ChunkedArray<UInt32Type>>,

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

Gather values from ChunkedArray by index.

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

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

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

Gather values from ChunkedArray by index.

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

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

Gather values from ChunkedArray by index.

impl<T> ChunkTakeUnchecked<ChunkedArray<UInt32Type>> for ChunkedArray<T>

where T: PolarsDataType<HasViews = FalseT, IsStruct = FalseT, IsNested = FalseT> + PolarsDataType,

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

Gather values from ChunkedArray by index.

impl<I> ChunkTakeUnchecked<I> for ChunkedArray<StringType>

where I: AsRef<[u32]> + ?Sized,

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

Gather values from ChunkedArray by index.

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

where T: PolarsDataType<HasViews = FalseT, IsStruct = FalseT, IsNested = FalseT> + PolarsDataType, I: AsRef<[u32]> + ?Sized,

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

Gather values from ChunkedArray by index.

impl ChunkUnique for ChunkedArray<StringType>

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

Get unique values of a ChunkedArray

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

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

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

Number of unique values in the ChunkedArray

impl<T> ChunkUnique for ChunkedArray<T>

where T: PolarsNumericType, <T as PolarsNumericType>::Native: TotalHash + TotalEq + ToTotalOrd, <<T as PolarsNumericType>::Native as ToTotalOrd>::TotalOrdItem: Hash + Eq + Ord, ChunkedArray<T>: IntoSeries + for<'a> ChunkCompareEq<&'a ChunkedArray<T>, Item = ChunkedArray<BooleanType>>,

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

Get unique values of a ChunkedArray

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

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

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

Number of unique values in the ChunkedArray

impl ChunkVar for ChunkedArray<StringType>

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkVar for ChunkedArray<T>

where T: PolarsNumericType, ChunkedArray<T>: ChunkAgg<<T as PolarsNumericType>::Native>,

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl<T> ChunkZip<T> for ChunkedArray<T>

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

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

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

impl<T> Clone for ChunkedArray<T>

where T: PolarsDataType,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Container for ChunkedArray<T>

where T: PolarsDataType,

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

fn split_at(&self, offset: i64) -> (ChunkedArray<T>, ChunkedArray<T>)

fn len(&self) -> usize

fn iter_chunks(&self) -> impl Iterator<Item = ChunkedArray<T>>

fn n_chunks(&self) -> usize

fn chunk_lengths(&self) -> impl Iterator<Item = usize>

impl Debug for ChunkedArray<StringType>

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

Formats the value using the given formatter.

impl<T> Debug for ChunkedArray<T>

where T: PolarsNumericType,

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

Formats the value using the given formatter.

impl<T> Default for ChunkedArray<T>

where T: PolarsDataType,

fn default() -> ChunkedArray<T>

Returns the “default value” for a type.

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

where T: PolarsNumericType, N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Div for ChunkedArray<T>

where T: PolarsNumericType,

type Output = ChunkedArray<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Drop for ChunkedArray<T>

where T: PolarsDataType,

fn drop(&mut self)

Executes the destructor for this type.

impl<T, A> From<A> for ChunkedArray<T>

where T: PolarsDataType<Array = A>, A: Array,

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

Converts to this type from the input type.

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

where T: PolarsNumericType,

fn from_iter<I>(iter: I) -> ChunkedArray<T>

where I: IntoIterator<Item = (Vec<<T as PolarsNumericType>::Native>, Option<Bitmap>)>,

Creates a value from an iterator.

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

where T: PolarsNumericType,

FromIterator trait

fn from_iter<I>(iter: I) -> ChunkedArray<T>

where I: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,

Creates a value from an iterator.

impl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<StringType>

where Ptr: AsRef<str>,

fn from_iter<I>(iter: I) -> ChunkedArray<StringType>

where I: IntoIterator<Item = Option<Ptr>>,

Creates a value from an iterator.

impl<Ptr> FromIterator<Ptr> for ChunkedArray<StringType>

where Ptr: PolarsAsRef<str>,

fn from_iter<I>(iter: I) -> ChunkedArray<StringType>

where I: IntoIterator<Item = Ptr>,

Creates a value from an iterator.

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

where T: PolarsNumericType,

fn from_trusted_len_iter_rev<I>(iter: I) -> ChunkedArray<T>

where I: TrustedLen<Item = Option<<T as PolarsNumericType>::Native>>,

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

where T: PolarsNumericType,

fn from_par_iter<I>(iter: I) -> ChunkedArray<T>

where I: IntoParallelIterator<Item = Option<<T as PolarsNumericType>::Native>>,

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

impl<Ptr> FromParallelIterator<Option<Ptr>> for ChunkedArray<StringType>

where Ptr: AsRef<str> + Send + Sync,

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.

impl<Ptr> FromParallelIterator<Ptr> for ChunkedArray<StringType>

where Ptr: PolarsAsRef<str> + Send + Sync + NoOption,

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.

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

where T: PolarsNumericType,

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<T>

where I: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>, <I as IntoIterator>::IntoIter: TrustedLen,

impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<StringType>

where Ptr: AsRef<str>,

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<StringType>

where I: IntoIterator<Item = Option<Ptr>>,

impl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<StringType>

where Ptr: PolarsAsRef<str>,

fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<StringType>

where I: IntoIterator<Item = Ptr>,

impl IntoGroupsType for ChunkedArray<StringType>

fn group_tuples<'a>( &'a self, multithreaded: bool, sorted: bool, ) -> Result<GroupsType, PolarsError>

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

impl<T> IntoGroupsType for ChunkedArray<T>

where T: PolarsNumericType, <T as PolarsNumericType>::Native: NumCast,

fn group_tuples( &self, multithreaded: bool, sorted: bool, ) -> Result<GroupsType, PolarsError>

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

impl<T> IntoSeries for ChunkedArray<T>

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

fn into_series(self) -> Series

where ChunkedArray<T>: Sized,

fn is_series() -> bool

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

where T: PolarsNumericType, N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul for ChunkedArray<T>

where T: PolarsNumericType,

type Output = ChunkedArray<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T> NamedFrom<T, [&'a str]> for ChunkedArray<StringType>

where T: AsRef<[&'a str]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Cow<'a, str>]> for ChunkedArray<StringType>

where T: AsRef<[Cow<'a, str>]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Option<&'a str>]> for ChunkedArray<StringType>

where T: AsRef<[Option<&'a str>]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<'a, T> NamedFrom<T, [Option<Cow<'a, str>>]> for ChunkedArray<StringType>

where T: AsRef<[Option<Cow<'a, str>>]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<String>]> for ChunkedArray<StringType>

where T: AsRef<[Option<String>]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<T> NamedFrom<T, [String]> for ChunkedArray<StringType>

where T: AsRef<[String]>,

fn new(name: PlSmallStr, v: T) -> ChunkedArray<StringType>

Initialize by name and values.

impl<S> NewChunkedArray<StringType, S> for ChunkedArray<StringType>

where S: AsRef<str>,

fn from_iter_values( name: PlSmallStr, it: impl Iterator<Item = S>, ) -> ChunkedArray<StringType>

Create a new ChunkedArray from an iterator.

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

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

fn from_iter_options( name: PlSmallStr, it: impl Iterator<Item = Option<S>>, ) -> ChunkedArray<StringType>

Create a new ChunkedArray from an iterator.

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

where T: PolarsNumericType,

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

Create a new ChunkedArray from an iterator.

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

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

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

Create a new ChunkedArray from an iterator.

impl<T> NumOpsDispatch for ChunkedArray<T>

where T: NumOpsDispatchInner,

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

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

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

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

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

impl<S> NumOpsDispatchChecked for ChunkedArray<S>

where S: NumOpsDispatchCheckedInner,

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

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

fn checked_div_num<T>(&self, rhs: T) -> Result<Series, PolarsError>

where T: ToPrimitive,

impl<T> QuantileAggSeries for ChunkedArray<T>

where T: PolarsIntegerType, <T as PolarsNumericType>::Native: Ord + WrappingSum,

fn quantile_reduce( &self, quantile: f64, method: QuantileMethod, ) -> Result<Scalar, PolarsError>

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

fn median_reduce(&self) -> Scalar

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

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

where T: PolarsNumericType, N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T> Rem for ChunkedArray<T>

where T: PolarsNumericType,

type Output = ChunkedArray<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T> Serialize for ChunkedArray<T>

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

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StringMethods for ChunkedArray<StringType>

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

Available on crate feature dtype-time only.

Parsing string values and return a TimeChunked

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

Available on crate feature dtype-date only.

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

fn as_datetime_not_exact( &self, fmt: Option<&str>, tu: TimeUnit, tz_aware: bool, tz: Option<&PlSmallStr>, _ambiguous: &ChunkedArray<StringType>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Available on crate feature dtype-datetime only.

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

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

Available on crate feature dtype-date only.

Parsing string values and return a DateChunked

fn as_datetime( &self, fmt: Option<&str>, tu: TimeUnit, use_cache: bool, tz_aware: bool, tz: Option<&PlSmallStr>, ambiguous: &ChunkedArray<StringType>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Available on crate feature dtype-datetime only.

Parsing string values and return a DatetimeChunked.

impl StringNameSpaceImpl for ChunkedArray<StringType>

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

Available on non-crate feature binary_encoding only.

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

Available on crate feature string_encoding only.

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

Available on non-crate feature binary_encoding only.

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

Available on crate feature string_encoding only.

fn to_integer( &self, base: &ChunkedArray<UInt32Type>, strict: bool, ) -> Result<ChunkedArray<Int64Type>, PolarsError>

Available on crate feature string_to_integer only.

fn contains_chunked( &self, pat: &ChunkedArray<StringType>, literal: bool, strict: bool, ) -> Result<ChunkedArray<BooleanType>, PolarsError>

fn find_chunked( &self, pat: &ChunkedArray<StringType>, literal: bool, strict: bool, ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

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

Check if strings starts with a substring

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

This is more performant than the BinaryChunked version because we use the inline prefix Use the BinaryChunked::ends_with as there is no specialization here for that

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

Get the length of the string values as number of chars.

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

Get the length of the string values as number of bytes.

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

Check if strings contain a regex pattern.

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

Check if strings contain a given literal

fn find_literal( &self, lit: &str, ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Return the index position of a literal substring in the target string.

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

Return the index position of a regular expression substring in the target string.

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

Replace the leftmost regex-matched (sub)string with another string

fn replace_literal<'a>( &'a self, pat: &str, val: &str, n: usize, ) -> Result<ChunkedArray<StringType>, PolarsError>

Replace the leftmost literal (sub)string with another string

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

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

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

Replace all matching literal (sub)strings with another string

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

Extract the nth capture group from pattern.

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

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

fn strip_chars( &self, pat: &Column, ) -> Result<ChunkedArray<StringType>, PolarsError>

fn strip_chars_start( &self, pat: &Column, ) -> Result<ChunkedArray<StringType>, PolarsError>

fn strip_chars_end( &self, pat: &Column, ) -> Result<ChunkedArray<StringType>, PolarsError>

fn strip_prefix( &self, prefix: &ChunkedArray<StringType>, ) -> ChunkedArray<StringType>

fn strip_suffix( &self, suffix: &ChunkedArray<StringType>, ) -> ChunkedArray<StringType>

fn split_exact( &self, by: &ChunkedArray<StringType>, n: usize, ) -> Result<ChunkedArray<StructType>, PolarsError>

Available on crate feature dtype-struct only.

fn split_exact_inclusive( &self, by: &ChunkedArray<StringType>, n: usize, ) -> Result<ChunkedArray<StructType>, PolarsError>

Available on crate feature dtype-struct only.

fn splitn( &self, by: &ChunkedArray<StringType>, n: usize, ) -> Result<ChunkedArray<StructType>, PolarsError>

Available on crate feature dtype-struct only.

fn split(&self, by: &ChunkedArray<StringType>) -> ChunkedArray<ListType>

fn split_inclusive( &self, by: &ChunkedArray<StringType>, ) -> ChunkedArray<ListType>

fn extract_all_many( &self, pat: &ChunkedArray<StringType>, ) -> Result<ChunkedArray<ListType>, PolarsError>

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

fn extract_groups( &self, pat: &str, dtype: &DataType, ) -> Result<Series, PolarsError>

Available on crate feature extract_groups only.

Extract all capture groups from pattern and return as a struct.

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

Count all successive non-overlapping regex matches.

fn count_matches_many( &self, pat: &ChunkedArray<StringType>, literal: bool, ) -> Result<ChunkedArray<UInt32Type>, PolarsError>

Count all successive non-overlapping regex matches.

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

Modify the strings to their lowercase equivalent.

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

Modify the strings to their uppercase equivalent.

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

Available on crate feature nightly only.

Modify the strings to their titlecase equivalent.

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

Concat with the values from a second StringChunked.

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

Available on crate feature string_reverse only.

Reverses the string values

fn str_slice( &self, offset: &Column, length: &Column, ) -> Result<ChunkedArray<StringType>, PolarsError>

Slice the string values.

fn str_head(&self, n: &Column) -> Result<ChunkedArray<StringType>, PolarsError>

Slice the first n values of the string.

fn str_tail(&self, n: &Column) -> Result<ChunkedArray<StringType>, PolarsError>

Slice the last n values of the string.

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

Available on crate feature strings only.

Escapes all regular expression meta characters in the string.

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

where T: PolarsNumericType, N: Num + ToPrimitive,

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> Sub for ChunkedArray<T>

where T: PolarsNumericType,

type Output = ChunkedArray<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T> TakeChunked for ChunkedArray<T>

where T: PolarsDataType, <T as PolarsDataType>::Array: Debug,

unsafe fn take_chunked_unchecked<const B: u64>( &self, by: &[ChunkId<B>], sorted: IsSorted, _allow_sharing: bool, ) -> ChunkedArray<T>

Gathers elements from a ChunkedArray, specifying for each element a chunk index and index within that chunk through ChunkId. If avoid_sharing is true the returned data should not share references with the original array (like shared buffers in views).

unsafe fn take_opt_chunked_unchecked<const B: u64>( &self, by: &[ChunkId<B>], _allow_sharing: bool, ) -> ChunkedArray<T>

Safety

impl ValueSize for ChunkedArray<StringType>

fn get_values_size(&self) -> usize

Get the values size that is still “visible” to the underlying array. E.g. take the offsets into account.

impl<T> VarAggSeries for ChunkedArray<T>

where T: PolarsIntegerType, ChunkedArray<T>: ChunkVar,

fn var_reduce(&self, ddof: u8) -> Scalar

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

fn std_reduce(&self, ddof: u8) -> Scalar

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

impl VecHash for ChunkedArray<StringType>

fn vec_hash( &self, random_state: SeedableRandomState, buf: &mut Vec<u64>, ) -> Result<(), PolarsError>

Compute the hash for all values in the array.

fn vec_hash_combine( &self, random_state: SeedableRandomState, hashes: &mut [u64], ) -> Result<(), PolarsError>