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, ChunkedArray’s are typed. This allows
us to apply closures to the data and collect the results to a ChunkedArray
of the same type T
.
Below we use an apply to use the cosine function to the values of a ChunkedArray
.
fn apply_cosine(ca: &Float32Chunked) -> Float32Chunked {
ca.apply(|v| v.cos())
}
If we would like to cast the result we could use a Rust Iterator instead of an apply
method.
Note that Iterators are slightly slower as the null values aren’t ignored implicitly.
fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
ca.into_iter()
.map(|opt_v| {
opt_v.map(|v| v.cos() as f64)
}).collect()
}
Another option is to first cast and then use an apply.
fn apply_cosine_and_cast(ca: &Float32Chunked) -> Float64Chunked {
ca.apply_cast_numeric(|v| v.cos() as f64)
}
Conversion between Series and ChunkedArray’s
Conversion from a Series
to a ChunkedArray
is effortless.
fn to_chunked_array(series: &Series) -> PolarsResult<&Int32Chunked>{
series.i32()
}
fn to_series(ca: Int32Chunked) -> Series {
ca.into_series()
}
Iterators
ChunkedArrays
fully support Rust native Iterator
and DoubleEndedIterator traits, thereby
giving access to all the excellent methods available for Iterators.
fn iter_forward(ca: &Float32Chunked) {
ca.into_iter()
.for_each(|opt_v| println!("{:?}", opt_v))
}
fn iter_backward(ca: &Float32Chunked) {
ca.into_iter()
.rev()
.for_each(|opt_v| println!("{:?}", opt_v))
}
Memory layout
ChunkedArray
’s use Apache Arrow as backend for the memory layout.
Arrows memory is immutable which makes it possible to make multiple zero copy (sub)-views from a single array.
To be able to append data, Polars uses chunks to append new memory locations, hence the ChunkedArray<T>
data structure.
Appends are cheap, because it will not lead to a full reallocation of the whole array (as could be the case with a Rust Vec).
However, multiple chunks in a ChunkArray
will slow down many operations that need random access because we have an extra indirection
and indexes need to be mapped to the proper chunk. Arithmetic may also be slowed down by this.
When multiplying two ChunkArray'
s with different chunk sizes they cannot utilize SIMD for instance.
If you want to have predictable performance (no unexpected re-allocation of memory), it is advised to call the ChunkedArray::rechunk after multiple append operations.
See also ChunkedArray::extend
for appends within a chunk.
Implementations
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Signed,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Signed,
sourcepub fn abs(&self) -> ChunkedArray<T>
pub fn abs(&self) -> ChunkedArray<T>
Convert all values to their absolute/positive value.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn append(&mut self, other: &ChunkedArray<T>)
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
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub 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,
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.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
pub fn apply_mut<F>(&mut self, f: F)where
F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,
impl ChunkedArray<Float32Type>
Used to save compilation paths. Use carefully. Although this is safe, if misused it can lead to incorrect results.
sourceimpl<T> ChunkedArray<T>where
T: PolarsDataType,
impl<T> ChunkedArray<T>where
T: PolarsDataType,
pub fn rechunk(&self) -> ChunkedArray<T>
sourcepub fn slice(&self, offset: i64, length: usize) -> ChunkedArray<T>
pub fn slice(&self, offset: i64, length: usize) -> ChunkedArray<T>
Slice the array. The chunks are reallocated the underlying data slices are zero copy.
When offset is negative it will be counted from the end of the array. This method will never error, and will slice the best match when offset, or length is out of bounds
sourcepub fn limit(&self, num_elements: usize) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
pub fn limit(&self, num_elements: usize) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
Take a view of top n elements
sourcepub fn head(&self, length: Option<usize>) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
pub fn head(&self, length: Option<usize>) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
Get the head of the ChunkedArray
sourcepub fn tail(&self, length: Option<usize>) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
pub fn tail(&self, length: Option<usize>) -> ChunkedArray<T>where
ChunkedArray<T>: Sized,
Get the tail of the ChunkedArray
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn extend(&mut self, other: &ChunkedArray<T>)
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
.
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
pub fn full_null_with_dtype(
name: &str,
length: usize,
inner_dtype: &DataType
) -> ChunkedArray<ListType>
sourceimpl<T> ChunkedArray<T>where
T: PolarsFloatType,
ChunkedArray<T>: IntoSeries,
<T as PolarsNumericType>::Native: Float,
<T as PolarsNumericType>::Native: IsFloat,
<T as PolarsNumericType>::Native: SubAssign<<T as PolarsNumericType>::Native>,
<T as PolarsNumericType>::Native: Pow<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Pow<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
impl<T> ChunkedArray<T>where
T: PolarsFloatType,
ChunkedArray<T>: IntoSeries,
<T as PolarsNumericType>::Native: Float,
<T as PolarsNumericType>::Native: IsFloat,
<T as PolarsNumericType>::Native: SubAssign<<T as PolarsNumericType>::Native>,
<T as PolarsNumericType>::Native: Pow<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Pow<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
sourcepub fn rolling_apply_float<F>(
&self,
window_size: usize,
f: F
) -> Result<ChunkedArray<T>, PolarsError>where
F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,
pub fn rolling_apply_float<F>(
&self,
window_size: usize,
f: F
) -> Result<ChunkedArray<T>, PolarsError>where
F: FnMut(&mut ChunkedArray<T>) -> Option<<T as PolarsNumericType>::Native>,
Apply a rolling custom function. This is pretty slow because of dynamic dispatch.
sourceimpl<T> ChunkedArray<T>where
T: PolarsFloatType,
<T as PolarsNumericType>::Native: Float,
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>
sourcepub fn none_to_nan(&self) -> ChunkedArray<T>
pub fn none_to_nan(&self) -> ChunkedArray<T>
Convert missing values to NaN
values.
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
pub fn par_iter(&self) -> impl ParallelIterator<Item = Option<Series>>
pub fn par_iter_indexed(&mut self) -> impl IndexedParallelIterator
sourceimpl ChunkedArray<Utf8Type>
impl ChunkedArray<Utf8Type>
pub fn par_iter_indexed(&self) -> impl IndexedParallelIterator
pub fn par_iter(&self) -> impl ParallelIterator<Item = Option<&str>>
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn to_ndarray(
&self
) -> Result<ArrayBase<ViewRepr<&<T as PolarsNumericType>::Native>, Dim<[usize; 1]>>, PolarsError>
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
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
sourcepub fn to_ndarray<N>(
&self
) -> Result<ArrayBase<OwnedRepr<<N as PolarsNumericType>::Native>, Dim<[usize; 2]>>, PolarsError>where
N: PolarsNumericType,
pub fn to_ndarray<N>(
&self
) -> Result<ArrayBase<OwnedRepr<<N as PolarsNumericType>::Native>, Dim<[usize; 2]>>, PolarsError>where
N: PolarsNumericType,
If all nested Series
have the same length, a 2 dimensional ndarray::Array
is returned.
sourceimpl<T> ChunkedArray<T>where
T: PolarsDataType,
impl<T> ChunkedArray<T>where
T: PolarsDataType,
sourcepub fn from_chunks(
name: &str,
chunks: Vec<Box<dyn Array + 'static, Global>, Global>
) -> ChunkedArray<T>
pub fn from_chunks(
name: &str,
chunks: Vec<Box<dyn Array + 'static, Global>, Global>
) -> ChunkedArray<T>
Create a new ChunkedArray from existing chunks.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn from_vec(
name: &str,
v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>
pub fn from_vec(
name: &str,
v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>
Create a new ChunkedArray by taking ownership of the Vec. This operation is zero copy.
sourcepub fn new_from_owned_with_null_bitmap(
name: &str,
values: Vec<<T as PolarsNumericType>::Native, Global>,
buffer: Option<Bitmap>
) -> ChunkedArray<T>
pub fn new_from_owned_with_null_bitmap(
name: &str,
values: Vec<<T as PolarsNumericType>::Native, Global>,
buffer: Option<Bitmap>
) -> ChunkedArray<T>
Nullify values in slice with an existing null bitmap
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
sourcepub fn amortized_iter(
&self
) -> AmortizedListIter<'_, impl Iterator<Item = Option<Box<dyn Array + 'static, Global>>>>
pub fn amortized_iter(
&self
) -> AmortizedListIter<'_, impl Iterator<Item = Option<Box<dyn Array + 'static, Global>>>>
This is an iterator over a ListChunked that save allocations.
A Series is:
1. Arc
The ArrayRef we indicated with 3. will be updated during iteration. The Series will be pinned in memory, saving an allocation for
- Arc<..>
- 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.
sourcepub fn apply_amortized<'a, F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: FnMut(UnstableSeries<'a>) -> Series,
pub fn apply_amortized<'a, F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: FnMut(UnstableSeries<'a>) -> Series,
Apply a closure F
elementwise.
pub fn try_apply_amortized<'a, F>(
&'a self,
f: F
) -> Result<ChunkedArray<ListType>, PolarsError>where
F: FnMut(UnstableSeries<'a>) -> Result<Series, PolarsError>,
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
pub fn set_fast_explode(&mut self)
pub fn to_logical(&mut self, inner_dtype: DataType)
sourceimpl ChunkedArray<Int64Type>
impl ChunkedArray<Int64Type>
pub fn into_datetime(
self,
timeunit: TimeUnit,
tz: Option<String>
) -> Logical<DatetimeType, Int64Type>
sourceimpl ChunkedArray<Int64Type>
impl ChunkedArray<Int64Type>
pub fn into_duration(
self,
timeunit: TimeUnit
) -> Logical<DurationType, Int64Type>
sourceimpl<T> ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkedArray<ObjectType<T>>where
T: PolarsObject,
pub fn new_from_vec(name: &str, v: Vec<T, Global>) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcepub unsafe fn get_object_unchecked(
&self,
index: usize
) -> Option<&(dyn PolarsObjectSafe + 'static)>
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
sourcepub fn get_object(
&self,
index: usize
) -> Option<&(dyn PolarsObjectSafe + 'static)>
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.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
Standard: Distribution<<T as PolarsNumericType>::Native>,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
Standard: Distribution<<T as PolarsNumericType>::Native>,
sourceimpl<T> ChunkedArray<T>where
T: PolarsDataType,
ChunkedArray<T>: ChunkTake,
impl<T> ChunkedArray<T>where
T: PolarsDataType,
ChunkedArray<T>: ChunkTake,
sourcepub fn sample_n(
&self,
n: usize,
with_replacement: bool,
shuffle: bool,
seed: Option<u64>
) -> Result<ChunkedArray<T>, PolarsError>
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.
sourcepub fn sample_frac(
&self,
frac: f64,
with_replacement: bool,
shuffle: bool,
seed: Option<u64>
) -> Result<ChunkedArray<T>, PolarsError>
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.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Float,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Float,
sourcepub fn rand_normal(
name: &str,
length: usize,
mean: f64,
std_dev: f64
) -> Result<ChunkedArray<T>, PolarsError>
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.
sourcepub fn rand_standard_normal(name: &str, length: usize) -> ChunkedArray<T>
pub fn rand_standard_normal(name: &str, length: usize) -> ChunkedArray<T>
Create ChunkedArray
with samples from a Standard Normal distribution.
sourcepub fn rand_uniform(
name: &str,
length: usize,
low: f64,
high: f64
) -> ChunkedArray<T>
pub fn rand_uniform(
name: &str,
length: usize,
low: f64,
high: f64
) -> ChunkedArray<T>
Create ChunkedArray
with samples from a Uniform distribution.
sourceimpl ChunkedArray<BooleanType>
impl ChunkedArray<BooleanType>
sourcepub fn rand_bernoulli(
name: &str,
length: usize,
p: f64
) -> Result<ChunkedArray<BooleanType>, PolarsError>
pub fn rand_bernoulli(
name: &str,
length: usize,
p: f64
) -> Result<ChunkedArray<BooleanType>, PolarsError>
Create ChunkedArray
with samples from a Bernoulli distribution.
sourceimpl ChunkedArray<Utf8Type>
impl ChunkedArray<Utf8Type>
pub fn hex_decode(
&self,
strict: Option<bool>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
pub fn hex_encode(&self) -> ChunkedArray<Utf8Type>
pub fn base64_decode(
&self,
strict: Option<bool>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
pub fn base64_encode(&self) -> ChunkedArray<Utf8Type>
sourceimpl<T> ChunkedArray<T>where
T: PolarsDataType,
impl<T> ChunkedArray<T>where
T: PolarsDataType,
sourcepub fn set_sorted(&mut self, reverse: bool)
pub fn set_sorted(&mut self, reverse: bool)
Set the ‘sorted’ bit meta info.
pub fn is_sorted2(&self) -> IsSorted
pub fn set_sorted2(&mut self, sorted: IsSorted)
sourcepub fn first_non_null(&self) -> Option<usize>
pub fn first_non_null(&self) -> Option<usize>
Get the index of the first non null value in this ChunkedArray.
sourcepub fn last_non_null(&self) -> Option<usize>
pub fn last_non_null(&self) -> Option<usize>
Get the index of the last non null value in this ChunkedArray.
sourcepub fn iter_validities(
&self
) -> Map<Iter<'_, Box<dyn Array + 'static, Global>>, fn(&Box<dyn Array + 'static, Global>) -> Option<&Bitmap>>
pub fn iter_validities(
&self
) -> Map<Iter<'_, Box<dyn Array + 'static, Global>>, fn(&Box<dyn Array + 'static, Global>) -> Option<&Bitmap>>
Get the buffer of bits representing null values
sourcepub fn has_validity(&self) -> bool
pub fn has_validity(&self) -> bool
Return if any the chunks in this [ChunkedArray]
have a validity bitmap.
no bitmap means no null values.
sourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
Shrink the capacity of this array to fit its length.
sourcepub fn unpack_series_matching_type(
&self,
series: &Series
) -> Result<&ChunkedArray<T>, PolarsError>
pub fn unpack_series_matching_type(
&self,
series: &Series
) -> Result<&ChunkedArray<T>, PolarsError>
Series to ChunkedArray
sourcepub fn chunk_id(
&self
) -> Map<Iter<'_, Box<dyn Array + 'static, Global>>, fn(&Box<dyn Array + 'static, Global>) -> usize>
pub fn chunk_id(
&self
) -> Map<Iter<'_, Box<dyn Array + 'static, Global>>, fn(&Box<dyn Array + 'static, Global>) -> usize>
Unique id representing the number of chunks
sourcepub fn chunks(&self) -> &Vec<Box<dyn Array + 'static, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
pub fn chunks(&self) -> &Vec<Box<dyn Array + 'static, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
A: Allocator,
A reference to the chunks
sourcepub unsafe fn chunks_mut(
&mut self
) -> &mut Vec<Box<dyn Array + 'static, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
pub unsafe fn chunks_mut(
&mut self
) -> &mut Vec<Box<dyn Array + 'static, Global>, Global>ⓘNotable traits for Vec<u8, A>impl<A> Write for Vec<u8, A>where
A: Allocator,
A: Allocator,
A mutable reference to the chunks
Safety
The caller must ensure to not change the DataType
or length
of any of the chunks.
sourcepub fn is_optimal_aligned(&self) -> bool
pub fn is_optimal_aligned(&self) -> bool
Returns true if contains a single chunk and has no null values
sourcepub fn null_count(&self) -> usize
pub fn null_count(&self) -> usize
Count the null values.
sourcepub fn append_array(
&mut self,
other: Box<dyn Array + 'static, Global>
) -> Result<(), PolarsError>
pub fn append_array(
&mut self,
other: Box<dyn Array + 'static, Global>
) -> Result<(), PolarsError>
Append arrow array in place.
let mut array = Int32Chunked::new("array", &[1, 2]);
let array_2 = Int32Chunked::new("2nd", &[3]);
array.append(&array_2);
assert_eq!(Vec::from(&array), [Some(1), Some(2), Some(3)])
sourcepub fn is_null(&self) -> ChunkedArray<BooleanType>
pub fn is_null(&self) -> ChunkedArray<BooleanType>
Get a mask of the null values.
sourcepub fn is_not_null(&self) -> ChunkedArray<BooleanType>
pub fn is_not_null(&self) -> ChunkedArray<BooleanType>
Get a mask of the valid values.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn cont_slice(
&self
) -> Result<&[<T as PolarsNumericType>::Native], PolarsError>
pub fn cont_slice(
&self
) -> Result<&[<T as PolarsNumericType>::Native], PolarsError>
Contiguous slice
sourcepub fn data_views(
&self
) -> impl Iterator<Item = &[<T as PolarsNumericType>::Native]> + DoubleEndedIterator
pub fn data_views(
&self
) -> impl Iterator<Item = &[<T as PolarsNumericType>::Native]> + DoubleEndedIterator
Get slices of the underlying arrow data. NOTE: null values should be taken into account by the user of these slices as they are handled separately
pub fn into_no_null_iter(
&self
) -> impl Iterator<Item = <T as PolarsNumericType>::Native> + Send + Sync + ExactSizeIterator + DoubleEndedIterator + TrustedLen
sourceimpl ChunkedArray<ListType>
impl ChunkedArray<ListType>
sourcepub fn inner_dtype(&self) -> DataType
pub fn inner_dtype(&self) -> DataType
Get the inner data type of the list.
pub fn set_inner_dtype(&mut self, dtype: DataType)
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkedArray<T>where
T: PolarsNumericType,
sourcepub fn new_vec(
name: &str,
v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>
pub fn new_vec(
name: &str,
v: Vec<<T as PolarsNumericType>::Native, Global>
) -> ChunkedArray<T>
Specialization that prevents an allocation
prefer this over ChunkedArray::new when you have a Vec<T::Native>
and no null values.
sourceimpl<T> ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
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)
sourcepub fn lhs_sub<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
pub fn lhs_sub<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
Apply lhs - self
sourcepub fn lhs_div<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
pub fn lhs_div<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
Apply lhs / self
sourcepub fn lhs_rem<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
pub fn lhs_rem<N>(&self, lhs: N) -> ChunkedArray<T>where
N: Num + NumCast,
Apply lhs % self
Trait Implementations
sourceimpl<T> Add<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Add<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
+
operator.sourcefn add(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Add<&ChunkedArray<T>>>::Output
fn add(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Add<&ChunkedArray<T>>>::Output
+
operation. Read moresourceimpl Add<&ChunkedArray<Utf8Type>> for &ChunkedArray<Utf8Type>
impl Add<&ChunkedArray<Utf8Type>> for &ChunkedArray<Utf8Type>
type Output = ChunkedArray<Utf8Type>
type Output = ChunkedArray<Utf8Type>
+
operator.sourcefn add(
self,
rhs: &ChunkedArray<Utf8Type>
) -> <&ChunkedArray<Utf8Type> as Add<&ChunkedArray<Utf8Type>>>::Output
fn add(
self,
rhs: &ChunkedArray<Utf8Type>
) -> <&ChunkedArray<Utf8Type> as Add<&ChunkedArray<Utf8Type>>>::Output
+
operation. Read moresourceimpl Add<&str> for &ChunkedArray<Utf8Type>
impl Add<&str> for &ChunkedArray<Utf8Type>
sourceimpl<T> Add<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Add<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
+
operator.sourcefn add(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Add<ChunkedArray<T>>>::Output
fn add(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Add<ChunkedArray<T>>>::Output
+
operation. Read moresourceimpl Add<ChunkedArray<Utf8Type>> for ChunkedArray<Utf8Type>
impl Add<ChunkedArray<Utf8Type>> for ChunkedArray<Utf8Type>
type Output = ChunkedArray<Utf8Type>
type Output = ChunkedArray<Utf8Type>
+
operator.sourcefn add(
self,
rhs: ChunkedArray<Utf8Type>
) -> <ChunkedArray<Utf8Type> as Add<ChunkedArray<Utf8Type>>>::Output
fn add(
self,
rhs: ChunkedArray<Utf8Type>
) -> <ChunkedArray<Utf8Type> as Add<ChunkedArray<Utf8Type>>>::Output
+
operation. Read moresourceimpl<T, N> Add<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Add<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
+
operator.sourceimpl<T, N> Add<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Add<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
+
operator.sourceimpl AggList for ChunkedArray<BooleanType>
impl AggList for ChunkedArray<BooleanType>
sourceunsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
sourceimpl AggList for ChunkedArray<ListType>
impl AggList for ChunkedArray<ListType>
sourceunsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
sourceimpl<T> AggList for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> AggList for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceunsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
sourceimpl<T> AggList for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
impl<T> AggList for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
sourceunsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
sourceimpl AggList for ChunkedArray<Utf8Type>
impl AggList for ChunkedArray<Utf8Type>
sourceunsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
unsafe fn agg_list(&self, groups: &GroupsProxy) -> Series
sourceimpl ArgAgg for ChunkedArray<BooleanType>
impl ArgAgg for ChunkedArray<BooleanType>
sourceimpl ArgAgg for ChunkedArray<ListType>
impl ArgAgg for ChunkedArray<ListType>
sourceimpl<T> ArgAgg for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ArgAgg for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceimpl<T> ArgAgg for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ArgAgg for ChunkedArray<T>where
T: PolarsNumericType,
sourceimpl ArgAgg for ChunkedArray<Utf8Type>
impl ArgAgg for ChunkedArray<Utf8Type>
sourceimpl AsList for ChunkedArray<ListType>
impl AsList for ChunkedArray<ListType>
fn as_list(&self) -> &ChunkedArray<ListType>
sourceimpl<'a, T> AsMut<ChunkedArray<T>> for dyn SeriesTrait + 'awhere
T: 'static + PolarsDataType,
impl<'a, T> AsMut<ChunkedArray<T>> for dyn SeriesTrait + 'awhere
T: 'static + PolarsDataType,
sourcefn as_mut(&mut self) -> &mut ChunkedArray<T>
fn as_mut(&mut self) -> &mut ChunkedArray<T>
sourceimpl<T> AsRef<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsDataType,
impl<T> AsRef<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsDataType,
sourcefn as_ref(&self) -> &ChunkedArray<T>
fn as_ref(&self) -> &ChunkedArray<T>
sourceimpl<'a, T> AsRef<ChunkedArray<T>> for dyn SeriesTrait + 'awhere
T: 'static + PolarsDataType,
impl<'a, T> AsRef<ChunkedArray<T>> for dyn SeriesTrait + 'awhere
T: 'static + PolarsDataType,
sourcefn as_ref(&self) -> &ChunkedArray<T>
fn as_ref(&self) -> &ChunkedArray<T>
sourceimpl AsUtf8 for ChunkedArray<Utf8Type>
impl AsUtf8 for ChunkedArray<Utf8Type>
fn as_utf8(&self) -> &ChunkedArray<Utf8Type>
sourceimpl BitAnd<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
impl BitAnd<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
&
operator.sourcefn bitand(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitAnd<&ChunkedArray<BooleanType>>>::Output
fn bitand(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitAnd<&ChunkedArray<BooleanType>>>::Output
&
operation. Read moresourceimpl<T> BitAnd<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitAnd<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitAnd<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
impl<T> BitAnd<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitAnd<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitAnd<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
&
operator.sourcefn bitand(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitAnd<&ChunkedArray<T>>>::Output
fn bitand(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitAnd<&ChunkedArray<T>>>::Output
&
operation. Read moresourceimpl BitAnd<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
impl BitAnd<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
&
operator.sourcefn bitand(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitAnd<ChunkedArray<BooleanType>>>::Output
fn bitand(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitAnd<ChunkedArray<BooleanType>>>::Output
&
operation. Read moresourceimpl BitOr<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
impl BitOr<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
|
operator.sourcefn bitor(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitOr<&ChunkedArray<BooleanType>>>::Output
fn bitor(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitOr<&ChunkedArray<BooleanType>>>::Output
|
operation. Read moresourceimpl<T> BitOr<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitOr<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitOr<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
impl<T> BitOr<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitOr<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitOr<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
|
operator.sourcefn bitor(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitOr<&ChunkedArray<T>>>::Output
fn bitor(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitOr<&ChunkedArray<T>>>::Output
|
operation. Read moresourceimpl BitOr<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
impl BitOr<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
|
operator.sourcefn bitor(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitOr<ChunkedArray<BooleanType>>>::Output
fn bitor(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitOr<ChunkedArray<BooleanType>>>::Output
|
operation. Read moresourceimpl BitXor<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
impl BitXor<&ChunkedArray<BooleanType>> for &ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
^
operator.sourcefn bitxor(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitXor<&ChunkedArray<BooleanType>>>::Output
fn bitxor(
self,
rhs: &ChunkedArray<BooleanType>
) -> <&ChunkedArray<BooleanType> as BitXor<&ChunkedArray<BooleanType>>>::Output
^
operation. Read moresourceimpl<T> BitXor<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitXor<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitXor<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
impl<T> BitXor<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: BitXor<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as BitXor<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
^
operator.sourcefn bitxor(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitXor<&ChunkedArray<T>>>::Output
fn bitxor(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as BitXor<&ChunkedArray<T>>>::Output
^
operation. Read moresourceimpl BitXor<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
impl BitXor<ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
^
operator.sourcefn bitxor(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitXor<ChunkedArray<BooleanType>>>::Output
fn bitxor(
self,
rhs: ChunkedArray<BooleanType>
) -> <ChunkedArray<BooleanType> as BitXor<ChunkedArray<BooleanType>>>::Output
^
operation. Read moresourceimpl<T> ChunkAgg<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> ChunkAgg<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourcefn sum(&self) -> Option<<T as PolarsNumericType>::Native>
fn sum(&self) -> Option<<T as PolarsNumericType>::Native>
None
if the array is empty or only contains null values. Read morefn min(&self) -> Option<<T as PolarsNumericType>::Native>
sourceimpl ChunkAgg<u32> for ChunkedArray<BooleanType>
impl ChunkAgg<u32> for ChunkedArray<BooleanType>
Booleans are casted to 1 or 0.
sourceimpl ChunkAggSeries for ChunkedArray<BooleanType>
impl ChunkAggSeries for ChunkedArray<BooleanType>
sourcefn sum_as_series(&self) -> Series
fn sum_as_series(&self) -> Series
sourcefn max_as_series(&self) -> Series
fn max_as_series(&self) -> Series
sourcefn min_as_series(&self) -> Series
fn min_as_series(&self) -> Series
sourcefn prod_as_series(&self) -> Series
fn prod_as_series(&self) -> Series
sourceimpl ChunkAggSeries for ChunkedArray<ListType>
impl ChunkAggSeries for ChunkedArray<ListType>
sourcefn sum_as_series(&self) -> Series
fn sum_as_series(&self) -> Series
sourcefn max_as_series(&self) -> Series
fn max_as_series(&self) -> Series
sourcefn min_as_series(&self) -> Series
fn min_as_series(&self) -> Series
sourcefn prod_as_series(&self) -> Series
fn prod_as_series(&self) -> Series
sourceimpl<T> ChunkAggSeries for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkAggSeries for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn sum_as_series(&self) -> Series
fn sum_as_series(&self) -> Series
sourcefn max_as_series(&self) -> Series
fn max_as_series(&self) -> Series
sourcefn min_as_series(&self) -> Series
fn min_as_series(&self) -> Series
sourcefn prod_as_series(&self) -> Series
fn prod_as_series(&self) -> Series
sourceimpl<T> ChunkAggSeries for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
ChunkedArray<T>: IntoSeries,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> ChunkAggSeries for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
ChunkedArray<T>: IntoSeries,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourcefn sum_as_series(&self) -> Series
fn sum_as_series(&self) -> Series
sourcefn max_as_series(&self) -> Series
fn max_as_series(&self) -> Series
sourcefn min_as_series(&self) -> Series
fn min_as_series(&self) -> Series
sourcefn prod_as_series(&self) -> Series
fn prod_as_series(&self) -> Series
sourceimpl ChunkAggSeries for ChunkedArray<Utf8Type>
impl ChunkAggSeries for ChunkedArray<Utf8Type>
sourcefn sum_as_series(&self) -> Series
fn sum_as_series(&self) -> Series
sourcefn max_as_series(&self) -> Series
fn max_as_series(&self) -> Series
sourcefn min_as_series(&self) -> Series
fn min_as_series(&self) -> Series
sourcefn prod_as_series(&self) -> Series
fn prod_as_series(&self) -> Series
sourceimpl ChunkAnyValue for ChunkedArray<BooleanType>
impl ChunkAnyValue for ChunkedArray<BooleanType>
sourceunsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
sourcefn get_any_value(&self, index: usize) -> AnyValue<'_>
fn get_any_value(&self, index: usize) -> AnyValue<'_>
sourceimpl ChunkAnyValue for ChunkedArray<ListType>
impl ChunkAnyValue for ChunkedArray<ListType>
sourceunsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
sourcefn get_any_value(&self, index: usize) -> AnyValue<'_>
fn get_any_value(&self, index: usize) -> AnyValue<'_>
sourceimpl<T> ChunkAnyValue for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkAnyValue for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceunsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
sourcefn get_any_value(&self, index: usize) -> AnyValue<'_>
fn get_any_value(&self, index: usize) -> AnyValue<'_>
sourceimpl<T> ChunkAnyValue for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkAnyValue for ChunkedArray<T>where
T: PolarsNumericType,
sourceunsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
sourcefn get_any_value(&self, index: usize) -> AnyValue<'_>
fn get_any_value(&self, index: usize) -> AnyValue<'_>
sourceimpl ChunkAnyValue for ChunkedArray<Utf8Type>
impl ChunkAnyValue for ChunkedArray<Utf8Type>
sourceunsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
unsafe fn get_any_value_unchecked(&self, index: usize) -> AnyValue<'_>
sourcefn get_any_value(&self, index: usize) -> AnyValue<'_>
fn get_any_value(&self, index: usize) -> AnyValue<'_>
sourceimpl<'a, T> ChunkApply<'a, &'a T, T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<'a, T> ChunkApply<'a, &'a T, T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn apply_cast_numeric<F, S>(&'a self, _f: F) -> ChunkedArray<S>where
F: Fn(&'a T) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn apply_cast_numeric<F, S>(&'a self, _f: F) -> ChunkedArray<S>where
F: Fn(&'a T) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn branch_apply_cast_numeric_no_null<F, S>(&'a self, _f: F) -> ChunkedArray<S>where
F: Fn(Option<&'a T>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn branch_apply_cast_numeric_no_null<F, S>(&'a self, _f: F) -> ChunkedArray<S>where
F: Fn(Option<&'a T>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn apply<F>(&'a self, f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn(&'a T) -> T + Copy,
fn apply<F>(&'a self, f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn(&'a T) -> T + Copy,
fn try_apply<F>(
&'a self,
_f: F
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>where
F: Fn(&'a T) -> Result<T, PolarsError> + Copy,
sourcefn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn(Option<&'a T>) -> Option<T> + Copy,
fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn(Option<&'a T>) -> Option<T> + Copy,
sourcefn apply_with_idx<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn((usize, &'a T)) -> T + Copy,
fn apply_with_idx<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn((usize, &'a T)) -> T + Copy,
sourcefn apply_with_idx_on_opt<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn((usize, Option<&'a T>)) -> Option<T> + Copy,
fn apply_with_idx_on_opt<F>(&'a self, _f: F) -> ChunkedArray<ObjectType<T>>where
F: Fn((usize, Option<&'a T>)) -> Option<T> + Copy,
sourceimpl<'a> ChunkApply<'a, &'a str, Cow<'a, str>> for ChunkedArray<Utf8Type>
impl<'a> ChunkApply<'a, &'a str, Cow<'a, str>> for ChunkedArray<Utf8Type>
sourcefn apply_cast_numeric<F, S>(&'a self, f: F) -> ChunkedArray<S>where
F: Fn(&'a str) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn apply_cast_numeric<F, S>(&'a self, f: F) -> ChunkedArray<S>where
F: Fn(&'a str) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn branch_apply_cast_numeric_no_null<F, S>(&'a self, f: F) -> ChunkedArray<S>where
F: Fn(Option<&'a str>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn branch_apply_cast_numeric_no_null<F, S>(&'a self, f: F) -> ChunkedArray<S>where
F: Fn(Option<&'a str>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn apply<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn(&'a str) -> Cow<'a, str> + Copy,
fn apply<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn(&'a str) -> Cow<'a, str> + Copy,
fn try_apply<F>(&'a self, f: F) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
F: Fn(&'a str) -> Result<Cow<'a, str>, PolarsError> + Copy,
sourcefn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn(Option<&'a str>) -> Option<Cow<'a, str>> + Copy,
fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn(Option<&'a str>) -> Option<Cow<'a, str>> + Copy,
sourcefn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn((usize, &'a str)) -> Cow<'a, str> + Copy,
fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<Utf8Type>where
F: Fn((usize, &'a str)) -> Cow<'a, str> + Copy,
sourceimpl<'a, T> ChunkApply<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
impl<'a, T> ChunkApply<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(<T as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(<T as PolarsNumericType>::Native) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<<T as PolarsNumericType>::Native>) -> <S as PolarsNumericType>::Native,
S: PolarsNumericType,
fn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<<T as PolarsNumericType>::Native>) -> <S as PolarsNumericType>::Native,
S: PolarsNumericType,
sourcefn apply<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,
fn apply<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn(<T as PolarsNumericType>::Native) -> <T as PolarsNumericType>::Native + Copy,
fn try_apply<F>(&'a self, f: F) -> Result<ChunkedArray<T>, PolarsError>where
F: Fn(<T as PolarsNumericType>::Native) -> Result<<T as PolarsNumericType>::Native, PolarsError> + Copy,
sourcefn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn(Option<<T as PolarsNumericType>::Native>) -> Option<<T as PolarsNumericType>::Native> + Copy,
fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn(Option<<T as PolarsNumericType>::Native>) -> Option<<T as PolarsNumericType>::Native> + Copy,
sourcefn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn((usize, <T as PolarsNumericType>::Native)) -> <T as PolarsNumericType>::Native + Copy,
fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn((usize, <T as PolarsNumericType>::Native)) -> <T as PolarsNumericType>::Native + Copy,
sourcefn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn((usize, Option<<T as PolarsNumericType>::Native>)) -> Option<<T as PolarsNumericType>::Native> + Copy,
fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<T>where
F: Fn((usize, Option<<T as PolarsNumericType>::Native>)) -> Option<<T as PolarsNumericType>::Native> + Copy,
sourcefn apply_to_slice<F, V>(&'a self, f: F, slice: &mut [V])where
F: Fn(Option<<T as PolarsNumericType>::Native>, &V) -> V,
fn apply_to_slice<F, V>(&'a self, f: F, slice: &mut [V])where
F: Fn(Option<<T as PolarsNumericType>::Native>, &V) -> V,
sourceimpl<'a> ChunkApply<'a, Series, Series> for ChunkedArray<ListType>
impl<'a> ChunkApply<'a, Series, Series> for ChunkedArray<ListType>
sourcefn apply<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn(Series) -> Series + Copy,
fn apply<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn(Series) -> Series + Copy,
Apply a closure F
elementwise.
sourcefn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn((usize, Series)) -> Series + Copy,
fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn((usize, Series)) -> Series + Copy,
Apply a closure elementwise. The closure gets the index of the element as first argument.
sourcefn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn((usize, Option<Series>)) -> Option<Series> + Copy,
fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn((usize, Option<Series>)) -> Option<Series> + Copy,
Apply a closure elementwise. The closure gets the index of the element as first argument.
sourcefn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Series) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Series) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<Series>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<Series>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn try_apply<F>(&'a self, f: F) -> Result<ChunkedArray<ListType>, PolarsError>where
F: Fn(Series) -> Result<Series, PolarsError> + Copy,
sourcefn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn(Option<Series>) -> Option<Series> + Copy,
fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<ListType>where
F: Fn(Option<Series>) -> Option<Series> + Copy,
sourceimpl<'a> ChunkApply<'a, bool, bool> for ChunkedArray<BooleanType>
impl<'a> ChunkApply<'a, bool, bool> for ChunkedArray<BooleanType>
sourcefn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(bool) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn apply_cast_numeric<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(bool) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<bool>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
fn branch_apply_cast_numeric_no_null<F, S>(&self, f: F) -> ChunkedArray<S>where
F: Fn(Option<bool>) -> <S as PolarsNumericType>::Native + Copy,
S: PolarsNumericType,
sourcefn apply<F>(&self, f: F) -> ChunkedArray<BooleanType>where
F: Fn(bool) -> bool + Copy,
fn apply<F>(&self, f: F) -> ChunkedArray<BooleanType>where
F: Fn(bool) -> bool + Copy,
fn try_apply<F>(&self, f: F) -> Result<ChunkedArray<BooleanType>, PolarsError>where
F: Fn(bool) -> Result<bool, PolarsError> + Copy,
sourcefn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn(Option<bool>) -> Option<bool> + Copy,
fn apply_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn(Option<bool>) -> Option<bool> + Copy,
sourcefn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn((usize, bool)) -> bool + Copy,
fn apply_with_idx<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn((usize, bool)) -> bool + Copy,
sourcefn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn((usize, Option<bool>)) -> Option<bool> + Copy,
fn apply_with_idx_on_opt<F>(&'a self, f: F) -> ChunkedArray<BooleanType>where
F: Fn((usize, Option<bool>)) -> Option<bool> + Copy,
sourceimpl ChunkApplyKernel<BooleanArray> for ChunkedArray<BooleanType>
impl ChunkApplyKernel<BooleanArray> for ChunkedArray<BooleanType>
sourcefn apply_kernel(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<BooleanType>
fn apply_kernel(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<BooleanType>
sourcefn apply_kernel_cast<S>(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<S>where
S: PolarsDataType,
fn apply_kernel_cast<S>(&self, f: &dyn Fn(&BooleanArray)) -> ChunkedArray<S>where
S: PolarsDataType,
sourceimpl<T> ChunkApplyKernel<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkApplyKernel<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn apply_kernel(
&self,
f: &dyn Fn(&PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>
fn apply_kernel(
&self,
f: &dyn Fn(&PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>
sourcefn apply_kernel_cast<S>(
&self,
f: &dyn Fn(&PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<S>where
S: PolarsDataType,
fn apply_kernel_cast<S>(
&self,
f: &dyn Fn(&PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<S>where
S: PolarsDataType,
sourceimpl ChunkApplyKernel<Utf8Array<i64>> for ChunkedArray<Utf8Type>
impl ChunkApplyKernel<Utf8Array<i64>> for ChunkedArray<Utf8Type>
sourcefn apply_kernel(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<Utf8Type>
fn apply_kernel(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<Utf8Type>
sourcefn apply_kernel_cast<S>(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<S>where
S: PolarsDataType,
fn apply_kernel_cast<S>(&self, f: &dyn Fn(&Utf8Array<i64>)) -> ChunkedArray<S>where
S: PolarsDataType,
sourceimpl ChunkCast for ChunkedArray<BooleanType>
impl ChunkCast for ChunkedArray<BooleanType>
sourcefn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
[ChunkedArray]
to [DataType]
sourcefn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
sourceimpl ChunkCast for ChunkedArray<ListType>
impl ChunkCast for ChunkedArray<ListType>
We cannot cast anything to or from List/LargeList So this implementation casts the inner type
sourcefn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
[ChunkedArray]
to [DataType]
sourcefn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
sourceimpl<T> ChunkCast for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkCast for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
[ChunkedArray]
to [DataType]
sourcefn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
sourceimpl ChunkCast for ChunkedArray<Utf8Type>
impl ChunkCast for ChunkedArray<Utf8Type>
sourcefn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast(&self, data_type: &DataType) -> Result<Series, PolarsError>
[ChunkedArray]
to [DataType]
sourcefn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
fn cast_unchecked(&self, data_type: &DataType) -> Result<Series, PolarsError>
sourceimpl ChunkCompare<&ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
impl ChunkCompare<&ChunkedArray<BooleanType>> for ChunkedArray<BooleanType>
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(
&self,
rhs: &ChunkedArray<BooleanType>
) -> ChunkedArray<BooleanType>
fn eq_missing(
&self,
rhs: &ChunkedArray<BooleanType>
) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourcefn gt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn gt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn gt_eq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourcefn lt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn lt(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
fn lt_eq(&self, rhs: &ChunkedArray<BooleanType>) -> ChunkedArray<BooleanType>
sourceimpl ChunkCompare<&ChunkedArray<ListType>> for ChunkedArray<ListType>
impl ChunkCompare<&ChunkedArray<ListType>> for ChunkedArray<ListType>
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn eq_missing(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn gt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn gt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn gt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn lt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn lt(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
fn lt_eq(&self, _rhs: &ChunkedArray<ListType>) -> ChunkedArray<BooleanType>
sourceimpl<T> ChunkCompare<&ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkCompare<&ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn eq_missing(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn gt(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn gt(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn gt_eq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn lt(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn lt(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
fn lt_eq(&self, rhs: &ChunkedArray<T>) -> ChunkedArray<BooleanType>
sourceimpl ChunkCompare<&ChunkedArray<Utf8Type>> for ChunkedArray<Utf8Type>
impl ChunkCompare<&ChunkedArray<Utf8Type>> for ChunkedArray<Utf8Type>
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn eq_missing(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn gt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn gt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn gt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn lt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn lt(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
fn lt_eq(&self, rhs: &ChunkedArray<Utf8Type>) -> ChunkedArray<BooleanType>
sourceimpl ChunkCompare<&str> for ChunkedArray<Utf8Type>
impl ChunkCompare<&str> for ChunkedArray<Utf8Type>
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn eq_missing(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn gt(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn gt(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn gt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn lt(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn lt(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>
fn lt_eq(&self, rhs: &str) -> ChunkedArray<BooleanType>
sourceimpl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T>where
T: PolarsNumericType,
Rhs: ToPrimitive,
impl<T, Rhs> ChunkCompare<Rhs> for ChunkedArray<T>where
T: PolarsNumericType,
Rhs: ToPrimitive,
type Item = ChunkedArray<BooleanType>
sourcefn eq_missing(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn eq_missing(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn equal(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn equal(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn not_equal(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn not_equal(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn gt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn gt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn gt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn gt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn lt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn lt(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourcefn lt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
fn lt_eq(&self, rhs: Rhs) -> ChunkedArray<BooleanType>
sourceimpl<T> ChunkCumAgg<T> for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: FromIterator<Option<<T as PolarsNumericType>::Native>>,
impl<T> ChunkCumAgg<T> for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: FromIterator<Option<<T as PolarsNumericType>::Native>>,
sourcefn cummax(&self, reverse: bool) -> ChunkedArray<T>
fn cummax(&self, reverse: bool) -> ChunkedArray<T>
sourcefn cummin(&self, reverse: bool) -> ChunkedArray<T>
fn cummin(&self, reverse: bool) -> ChunkedArray<T>
sourcefn cumsum(&self, reverse: bool) -> ChunkedArray<T>
fn cumsum(&self, reverse: bool) -> ChunkedArray<T>
sourcefn cumprod(&self, reverse: bool) -> ChunkedArray<T>
fn cumprod(&self, reverse: bool) -> ChunkedArray<T>
sourceimpl ChunkExpandAtIndex<BooleanType> for ChunkedArray<BooleanType>
impl ChunkExpandAtIndex<BooleanType> for ChunkedArray<BooleanType>
sourcefn expand_at_index(
&self,
index: usize,
length: usize
) -> ChunkedArray<BooleanType>
fn expand_at_index(
&self,
index: usize,
length: usize
) -> ChunkedArray<BooleanType>
sourceimpl ChunkExpandAtIndex<ListType> for ChunkedArray<ListType>
impl ChunkExpandAtIndex<ListType> for ChunkedArray<ListType>
sourcefn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<ListType>
fn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<ListType>
sourceimpl<T> ChunkExpandAtIndex<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkExpandAtIndex<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn expand_at_index(
&self,
index: usize,
length: usize
) -> ChunkedArray<ObjectType<T>>
fn expand_at_index(
&self,
index: usize,
length: usize
) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkExpandAtIndex<T> for ChunkedArray<T>where
T: PolarsDataType + PolarsNumericType,
ChunkedArray<T>: ChunkFull<<T as PolarsNumericType>::Native>,
ChunkedArray<T>: TakeRandom,
<ChunkedArray<T> as TakeRandom>::Item == <T as PolarsNumericType>::Native,
impl<T> ChunkExpandAtIndex<T> for ChunkedArray<T>where
T: PolarsDataType + PolarsNumericType,
ChunkedArray<T>: ChunkFull<<T as PolarsNumericType>::Native>,
ChunkedArray<T>: TakeRandom,
<ChunkedArray<T> as TakeRandom>::Item == <T as PolarsNumericType>::Native,
sourcefn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<T>
fn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<T>
sourceimpl ChunkExpandAtIndex<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkExpandAtIndex<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<Utf8Type>
fn expand_at_index(&self, index: usize, length: usize) -> ChunkedArray<Utf8Type>
sourceimpl ChunkExplode for ChunkedArray<ListType>
impl ChunkExplode for ChunkedArray<ListType>
fn explode_and_offsets(&self) -> Result<(Series, Buffer<i64>), PolarsError>
fn explode(&self) -> Result<Series, PolarsError>
sourceimpl ChunkExplode for ChunkedArray<Utf8Type>
impl ChunkExplode for ChunkedArray<Utf8Type>
fn explode_and_offsets(&self) -> Result<(Series, Buffer<i64>), PolarsError>
fn explode(&self) -> Result<Series, PolarsError>
sourceimpl ChunkFillNull for ChunkedArray<BooleanType>
impl ChunkFillNull for ChunkedArray<BooleanType>
sourcefn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl ChunkFillNull for ChunkedArray<ListType>
impl ChunkFillNull for ChunkedArray<ListType>
sourcefn fill_null(
&self,
_strategy: FillNullStrategy
) -> Result<ChunkedArray<ListType>, PolarsError>
fn fill_null(
&self,
_strategy: FillNullStrategy
) -> Result<ChunkedArray<ListType>, PolarsError>
sourceimpl<T> ChunkFillNull for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkFillNull for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn fill_null(
&self,
_strategy: FillNullStrategy
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
fn fill_null(
&self,
_strategy: FillNullStrategy
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
sourceimpl<T> ChunkFillNull for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> ChunkFillNull for ChunkedArray<T>where
T: PolarsNumericType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourcefn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<T>, PolarsError>
fn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl ChunkFillNull for ChunkedArray<Utf8Type>
impl ChunkFillNull for ChunkedArray<Utf8Type>
sourcefn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn fill_null(
&self,
strategy: FillNullStrategy
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourceimpl ChunkFillNullValue<&Series> for ChunkedArray<ListType>
impl ChunkFillNullValue<&Series> for ChunkedArray<ListType>
sourcefn fill_null_with_values(
&self,
_value: &Series
) -> Result<ChunkedArray<ListType>, PolarsError>
fn fill_null_with_values(
&self,
_value: &Series
) -> Result<ChunkedArray<ListType>, PolarsError>
T
.sourceimpl ChunkFillNullValue<&str> for ChunkedArray<Utf8Type>
impl ChunkFillNullValue<&str> for ChunkedArray<Utf8Type>
sourcefn fill_null_with_values(
&self,
value: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn fill_null_with_values(
&self,
value: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
T
.sourceimpl<T> ChunkFillNullValue<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkFillNullValue<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn fill_null_with_values(
&self,
value: <T as PolarsNumericType>::Native
) -> Result<ChunkedArray<T>, PolarsError>
fn fill_null_with_values(
&self,
value: <T as PolarsNumericType>::Native
) -> Result<ChunkedArray<T>, PolarsError>
T
.sourceimpl<T> ChunkFillNullValue<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkFillNullValue<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn fill_null_with_values(
&self,
_value: ObjectType<T>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
fn fill_null_with_values(
&self,
_value: ObjectType<T>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
T
.sourceimpl ChunkFillNullValue<bool> for ChunkedArray<BooleanType>
impl ChunkFillNullValue<bool> for ChunkedArray<BooleanType>
sourcefn fill_null_with_values(
&self,
value: bool
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn fill_null_with_values(
&self,
value: bool
) -> Result<ChunkedArray<BooleanType>, PolarsError>
T
.sourceimpl ChunkFilter<BooleanType> for ChunkedArray<BooleanType>
impl ChunkFilter<BooleanType> for ChunkedArray<BooleanType>
sourcefn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl ChunkFilter<ListType> for ChunkedArray<ListType>
impl ChunkFilter<ListType> for ChunkedArray<ListType>
sourcefn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ListType>, PolarsError>
fn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ListType>, PolarsError>
sourceimpl<T> ChunkFilter<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkFilter<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>where
ChunkedArray<ObjectType<T>>: Sized,
fn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>where
ChunkedArray<ObjectType<T>>: Sized,
sourceimpl<T> ChunkFilter<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkFilter<T> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<T>, PolarsError>
fn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl ChunkFilter<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkFilter<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn filter(
&self,
filter: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourceimpl<'a> ChunkFull<&'a str> for ChunkedArray<Utf8Type>
impl<'a> ChunkFull<&'a str> for ChunkedArray<Utf8Type>
sourceimpl ChunkFull<&Series> for ChunkedArray<ListType>
impl ChunkFull<&Series> for ChunkedArray<ListType>
sourceimpl<T> ChunkFull<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkFull<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn full(
name: &str,
value: <T as PolarsNumericType>::Native,
length: usize
) -> ChunkedArray<T>
fn full(
name: &str,
value: <T as PolarsNumericType>::Native,
length: usize
) -> ChunkedArray<T>
sourceimpl<T> ChunkFull<T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkFull<T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn full(name: &str, value: T, length: usize) -> ChunkedArray<ObjectType<T>>where
ChunkedArray<ObjectType<T>>: Sized,
fn full(name: &str, value: T, length: usize) -> ChunkedArray<ObjectType<T>>where
ChunkedArray<ObjectType<T>>: Sized,
sourceimpl ChunkFull<bool> for ChunkedArray<BooleanType>
impl ChunkFull<bool> for ChunkedArray<BooleanType>
sourcefn full(name: &str, value: bool, length: usize) -> ChunkedArray<BooleanType>
fn full(name: &str, value: bool, length: usize) -> ChunkedArray<BooleanType>
sourceimpl ChunkFullNull for ChunkedArray<BooleanType>
impl ChunkFullNull for ChunkedArray<BooleanType>
fn full_null(name: &str, length: usize) -> ChunkedArray<BooleanType>
sourceimpl ChunkFullNull for ChunkedArray<ListType>
impl ChunkFullNull for ChunkedArray<ListType>
sourceimpl<T> ChunkFullNull for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkFullNull for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
fn full_null(name: &str, length: usize) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkFullNull for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkFullNull for ChunkedArray<T>where
T: PolarsNumericType,
fn full_null(name: &str, length: usize) -> ChunkedArray<T>
sourceimpl ChunkFullNull for ChunkedArray<Utf8Type>
impl ChunkFullNull for ChunkedArray<Utf8Type>
sourceimpl<T> ChunkPeaks for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkPeaks for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn peak_max(&self) -> ChunkedArray<BooleanType>
fn peak_max(&self) -> ChunkedArray<BooleanType>
Get a boolean mask of the local maximum peaks.
sourcefn peak_min(&self) -> ChunkedArray<BooleanType>
fn peak_min(&self) -> ChunkedArray<BooleanType>
Get a boolean mask of the local minimum peaks.
sourceimpl ChunkQuantile<Series> for ChunkedArray<ListType>
impl ChunkQuantile<Series> for ChunkedArray<ListType>
sourcefn median(&self) -> Option<T>
fn median(&self) -> Option<T>
None
if the array is empty or only contains null values. Read moresourcefn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
fn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl<T> ChunkQuantile<Series> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkQuantile<Series> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn median(&self) -> Option<T>
fn median(&self) -> Option<T>
None
if the array is empty or only contains null values. Read moresourcefn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
fn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl ChunkQuantile<String> for ChunkedArray<Utf8Type>
impl ChunkQuantile<String> for ChunkedArray<Utf8Type>
sourcefn median(&self) -> Option<T>
fn median(&self) -> Option<T>
None
if the array is empty or only contains null values. Read moresourcefn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
fn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl ChunkQuantile<bool> for ChunkedArray<BooleanType>
impl ChunkQuantile<bool> for ChunkedArray<BooleanType>
sourcefn median(&self) -> Option<T>
fn median(&self) -> Option<T>
None
if the array is empty or only contains null values. Read moresourcefn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
fn quantile(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Option<T>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl ChunkQuantile<f32> for ChunkedArray<Float32Type>
impl ChunkQuantile<f32> for ChunkedArray<Float32Type>
sourcefn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f32>, PolarsError>
fn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f32>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl ChunkQuantile<f64> for ChunkedArray<Float64Type>
impl ChunkQuantile<f64> for ChunkedArray<Float64Type>
sourcefn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f64>, PolarsError>
fn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f64>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl<T> ChunkQuantile<f64> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Ord,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> ChunkQuantile<f64> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Ord,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourcefn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f64>, PolarsError>
fn quantile(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Option<f64>, PolarsError>
None
if the array is empty or only contains null values. Read moresourceimpl ChunkReverse<BooleanType> for ChunkedArray<BooleanType>
impl ChunkReverse<BooleanType> for ChunkedArray<BooleanType>
sourcefn reverse(&self) -> ChunkedArray<BooleanType>
fn reverse(&self) -> ChunkedArray<BooleanType>
sourceimpl ChunkReverse<ListType> for ChunkedArray<ListType>
impl ChunkReverse<ListType> for ChunkedArray<ListType>
sourcefn reverse(&self) -> ChunkedArray<ListType>
fn reverse(&self) -> ChunkedArray<ListType>
sourceimpl<T> ChunkReverse<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkReverse<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn reverse(&self) -> ChunkedArray<ObjectType<T>>
fn reverse(&self) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkReverse<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkReverse<T> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn reverse(&self) -> ChunkedArray<T>
fn reverse(&self) -> ChunkedArray<T>
sourceimpl ChunkReverse<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkReverse<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn reverse(&self) -> ChunkedArray<Utf8Type>
fn reverse(&self) -> ChunkedArray<Utf8Type>
sourceimpl<T> ChunkRollApply for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
impl<T> ChunkRollApply for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
sourcefn rolling_apply(
&self,
f: &dyn Fn(&Series),
options: RollingOptionsFixedWindow
) -> Result<Series, PolarsError>
fn rolling_apply(
&self,
f: &dyn Fn(&Series),
options: RollingOptionsFixedWindow
) -> Result<Series, PolarsError>
Apply a rolling custom function. This is pretty slow because of dynamic dispatch.
sourceimpl<'a> ChunkSet<'a, &'a str, String> for ChunkedArray<Utf8Type>
impl<'a> ChunkSet<'a, &'a str, String> for ChunkedArray<Utf8Type>
sourcefn set_at_idx<I>(
&'a self,
idx: I,
opt_value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: IntoIterator<Item = u32>,
ChunkedArray<Utf8Type>: Sized,
fn set_at_idx<I>(
&'a self,
idx: I,
opt_value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: IntoIterator<Item = u32>,
ChunkedArray<Utf8Type>: Sized,
sourcefn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<&'a str>) -> Option<String>,
ChunkedArray<Utf8Type>: Sized,
fn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<&'a str>) -> Option<String>,
ChunkedArray<Utf8Type>: Sized,
idx
by applying a closure to these values. Read moresourcefn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
ChunkedArray<Utf8Type>: Sized,
fn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<&'a str>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
ChunkedArray<Utf8Type>: Sized,
sourceimpl<'a, T> ChunkSet<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
impl<'a, T> ChunkSet<'a, <T as PolarsNumericType>::Native, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn set_at_idx<I>(
&'a self,
idx: I,
value: Option<<T as PolarsNumericType>::Native>
) -> Result<ChunkedArray<T>, PolarsError>where
I: IntoIterator<Item = u32>,
fn set_at_idx<I>(
&'a self,
idx: I,
value: Option<<T as PolarsNumericType>::Native>
) -> Result<ChunkedArray<T>, PolarsError>where
I: IntoIterator<Item = u32>,
sourcefn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<T>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<<T as PolarsNumericType>::Native>) -> Option<<T as PolarsNumericType>::Native>,
fn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<T>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<<T as PolarsNumericType>::Native>) -> Option<<T as PolarsNumericType>::Native>,
idx
by applying a closure to these values. Read moresourcefn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<<T as PolarsNumericType>::Native>
) -> Result<ChunkedArray<T>, PolarsError>
fn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<<T as PolarsNumericType>::Native>
) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl<'a> ChunkSet<'a, bool, bool> for ChunkedArray<BooleanType>
impl<'a> ChunkSet<'a, bool, bool> for ChunkedArray<BooleanType>
sourcefn set_at_idx<I>(
&'a self,
idx: I,
value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: IntoIterator<Item = u32>,
fn set_at_idx<I>(
&'a self,
idx: I,
value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: IntoIterator<Item = u32>,
sourcefn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<bool>) -> Option<bool>,
fn set_at_idx_with<I, F>(
&'a self,
idx: I,
f: F
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: IntoIterator<Item = u32>,
F: Fn(Option<bool>) -> Option<bool>,
idx
by applying a closure to these values. Read moresourcefn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn set(
&'a self,
mask: &ChunkedArray<BooleanType>,
value: Option<bool>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl ChunkShift<BooleanType> for ChunkedArray<BooleanType>
impl ChunkShift<BooleanType> for ChunkedArray<BooleanType>
fn shift(&self, periods: i64) -> ChunkedArray<BooleanType>
sourceimpl ChunkShift<ListType> for ChunkedArray<ListType>
impl ChunkShift<ListType> for ChunkedArray<ListType>
fn shift(&self, periods: i64) -> ChunkedArray<ListType>
sourceimpl<T> ChunkShift<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkShift<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
fn shift(&self, periods: i64) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkShift<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkShift<T> for ChunkedArray<T>where
T: PolarsNumericType,
fn shift(&self, periods: i64) -> ChunkedArray<T>
sourceimpl ChunkShift<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkShift<Utf8Type> for ChunkedArray<Utf8Type>
fn shift(&self, periods: i64) -> ChunkedArray<Utf8Type>
sourceimpl ChunkShiftFill<BooleanType, Option<bool>> for ChunkedArray<BooleanType>
impl ChunkShiftFill<BooleanType, Option<bool>> for ChunkedArray<BooleanType>
sourcefn shift_and_fill(
&self,
periods: i64,
fill_value: Option<bool>
) -> ChunkedArray<BooleanType>
fn shift_and_fill(
&self,
periods: i64,
fill_value: Option<bool>
) -> ChunkedArray<BooleanType>
fill_value
. Read moresourceimpl ChunkShiftFill<ListType, Option<&Series>> for ChunkedArray<ListType>
impl ChunkShiftFill<ListType, Option<&Series>> for ChunkedArray<ListType>
sourcefn shift_and_fill(
&self,
periods: i64,
fill_value: Option<&Series>
) -> ChunkedArray<ListType>
fn shift_and_fill(
&self,
periods: i64,
fill_value: Option<&Series>
) -> ChunkedArray<ListType>
fill_value
. Read moresourceimpl<T> ChunkShiftFill<ObjectType<T>, Option<ObjectType<T>>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkShiftFill<ObjectType<T>, Option<ObjectType<T>>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn shift_and_fill(
&self,
_periods: i64,
_fill_value: Option<ObjectType<T>>
) -> ChunkedArray<ObjectType<T>>
fn shift_and_fill(
&self,
_periods: i64,
_fill_value: Option<ObjectType<T>>
) -> ChunkedArray<ObjectType<T>>
fill_value
. Read moresourceimpl<T> ChunkShiftFill<T, Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkShiftFill<T, Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn shift_and_fill(
&self,
periods: i64,
fill_value: Option<<T as PolarsNumericType>::Native>
) -> ChunkedArray<T>
fn shift_and_fill(
&self,
periods: i64,
fill_value: Option<<T as PolarsNumericType>::Native>
) -> ChunkedArray<T>
fill_value
. Read moresourceimpl ChunkShiftFill<Utf8Type, Option<&str>> for ChunkedArray<Utf8Type>
impl ChunkShiftFill<Utf8Type, Option<&str>> for ChunkedArray<Utf8Type>
sourcefn shift_and_fill(
&self,
periods: i64,
fill_value: Option<&str>
) -> ChunkedArray<Utf8Type>
fn shift_and_fill(
&self,
periods: i64,
fill_value: Option<&str>
) -> ChunkedArray<Utf8Type>
fill_value
. Read moresourceimpl ChunkSort<BooleanType> for ChunkedArray<BooleanType>
impl ChunkSort<BooleanType> for ChunkedArray<BooleanType>
fn sort_with(&self, options: SortOptions) -> ChunkedArray<BooleanType>
sourcefn sort(&self, reverse: bool) -> ChunkedArray<BooleanType>
fn sort(&self, reverse: bool) -> ChunkedArray<BooleanType>
ChunkedArray
.sourcefn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
sourcefn argsort_multiple(
&self,
_other: &[Series],
_reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn argsort_multiple(
&self,
_other: &[Series],
_reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
sourceimpl ChunkSort<Float32Type> for ChunkedArray<Float32Type>
impl ChunkSort<Float32Type> for ChunkedArray<Float32Type>
sourcefn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
Panics
This function is very opinionated.
We assume that all numeric Series
are of the same type, if not it will panic
fn sort_with(&self, options: SortOptions) -> ChunkedArray<Float32Type>
sourcefn sort(&self, reverse: bool) -> ChunkedArray<Float32Type>
fn sort(&self, reverse: bool) -> ChunkedArray<Float32Type>
ChunkedArray
.sourcefn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
sourceimpl ChunkSort<Float64Type> for ChunkedArray<Float64Type>
impl ChunkSort<Float64Type> for ChunkedArray<Float64Type>
sourcefn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
Panics
This function is very opinionated.
We assume that all numeric Series
are of the same type, if not it will panic
fn sort_with(&self, options: SortOptions) -> ChunkedArray<Float64Type>
sourcefn sort(&self, reverse: bool) -> ChunkedArray<Float64Type>
fn sort(&self, reverse: bool) -> ChunkedArray<Float64Type>
ChunkedArray
.sourcefn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
sourceimpl<T> ChunkSort<T> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Default,
<T as PolarsNumericType>::Native: Ord,
impl<T> ChunkSort<T> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Default,
<T as PolarsNumericType>::Native: Ord,
sourcefn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
Panics
This function is very opinionated.
We assume that all numeric Series
are of the same type, if not it will panic
fn sort_with(&self, options: SortOptions) -> ChunkedArray<T>
sourcefn sort(&self, reverse: bool) -> ChunkedArray<T>
fn sort(&self, reverse: bool) -> ChunkedArray<T>
ChunkedArray
.sourcefn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
sourceimpl ChunkSort<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkSort<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn argsort_multiple(
&self,
other: &[Series],
reverse: &[bool]
) -> Result<ChunkedArray<UInt32Type>, PolarsError>
Panics
This function is very opinionated. On the implementation of ChunkedArray<T>
for numeric types,
we assume that all numeric Series
are of the same type.
In this case we assume that all numeric Series
are f64
types. The caller needs to
uphold this contract. If not, it will panic.
fn sort_with(&self, options: SortOptions) -> ChunkedArray<Utf8Type>
sourcefn sort(&self, reverse: bool) -> ChunkedArray<Utf8Type>
fn sort(&self, reverse: bool) -> ChunkedArray<Utf8Type>
ChunkedArray
.sourcefn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
fn argsort(&self, options: SortOptions) -> ChunkedArray<UInt32Type>
sourceimpl ChunkTake for ChunkedArray<BooleanType>
impl ChunkTake for ChunkedArray<BooleanType>
sourceunsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<BooleanType>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<BooleanType>: Sized,
unsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<BooleanType>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<BooleanType>: Sized,
sourcefn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<BooleanType>: Sized,
fn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<BooleanType>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<BooleanType>: Sized,
sourceimpl ChunkTake for ChunkedArray<ListType>
impl ChunkTake for ChunkedArray<ListType>
sourceunsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<ListType>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ListType>: Sized,
unsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<ListType>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ListType>: Sized,
sourcefn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<ListType>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ListType>: Sized,
fn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<ListType>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ListType>: Sized,
sourceimpl<T> ChunkTake for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkTake for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceunsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<ObjectType<T>>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ObjectType<T>>: Sized,
unsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<ObjectType<T>>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ObjectType<T>>: Sized,
sourcefn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ObjectType<T>>: Sized,
fn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<ObjectType<T>>: Sized,
sourceimpl<T> ChunkTake for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkTake for ChunkedArray<T>where
T: PolarsNumericType,
sourceunsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<T>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<T>: Sized,
unsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<T>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<T>: Sized,
sourcefn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<T>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<T>: Sized,
fn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<T>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<T>: Sized,
sourceimpl ChunkTake for ChunkedArray<Utf8Type>
impl ChunkTake for ChunkedArray<Utf8Type>
sourceunsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<Utf8Type>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<Utf8Type>: Sized,
unsafe fn take_unchecked<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> ChunkedArray<Utf8Type>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<Utf8Type>: Sized,
sourcefn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<Utf8Type>: Sized,
fn take<I, INulls>(
&self,
indices: TakeIdx<'_, I, INulls>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>where
I: TakeIterator,
INulls: TakeIteratorNulls,
ChunkedArray<Utf8Type>: Sized,
sourceimpl ChunkTakeEvery<BooleanType> for ChunkedArray<BooleanType>
impl ChunkTakeEvery<BooleanType> for ChunkedArray<BooleanType>
sourcefn take_every(&self, n: usize) -> ChunkedArray<BooleanType>
fn take_every(&self, n: usize) -> ChunkedArray<BooleanType>
sourceimpl ChunkTakeEvery<ListType> for ChunkedArray<ListType>
impl ChunkTakeEvery<ListType> for ChunkedArray<ListType>
sourcefn take_every(&self, n: usize) -> ChunkedArray<ListType>
fn take_every(&self, n: usize) -> ChunkedArray<ListType>
sourceimpl<T> ChunkTakeEvery<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkTakeEvery<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn take_every(&self, _n: usize) -> ChunkedArray<ObjectType<T>>
fn take_every(&self, _n: usize) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> ChunkTakeEvery<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkTakeEvery<T> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn take_every(&self, n: usize) -> ChunkedArray<T>
fn take_every(&self, n: usize) -> ChunkedArray<T>
sourceimpl ChunkTakeEvery<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkTakeEvery<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn take_every(&self, n: usize) -> ChunkedArray<Utf8Type>
fn take_every(&self, n: usize) -> ChunkedArray<Utf8Type>
sourceimpl ChunkUnique<BooleanType> for ChunkedArray<BooleanType>
impl ChunkUnique<BooleanType> for ChunkedArray<BooleanType>
sourcefn unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl ChunkUnique<Float32Type> for ChunkedArray<Float32Type>
impl ChunkUnique<Float32Type> for ChunkedArray<Float32Type>
sourcefn unique(&self) -> Result<ChunkedArray<Float32Type>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<Float32Type>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl ChunkUnique<Float64Type> for ChunkedArray<Float64Type>
impl ChunkUnique<Float64Type> for ChunkedArray<Float64Type>
sourcefn unique(&self) -> Result<ChunkedArray<Float64Type>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<Float64Type>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl<T> ChunkUnique<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkUnique<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn unique(&self) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl<T> ChunkUnique<T> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Hash,
<T as PolarsNumericType>::Native: Eq,
<T as PolarsNumericType>::Native: Ord,
ChunkedArray<T>: IntoSeries,
impl<T> ChunkUnique<T> for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Hash,
<T as PolarsNumericType>::Native: Eq,
<T as PolarsNumericType>::Native: Ord,
ChunkedArray<T>: IntoSeries,
sourcefn unique(&self) -> Result<ChunkedArray<T>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<T>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<T>, PolarsError>
sourceimpl ChunkUnique<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkUnique<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn unique(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn unique(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn arg_unique(&self) -> Result<ChunkedArray<UInt32Type>, PolarsError>
ChunkedArray
.
This Vec is sorted. Read moresourcefn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_unique(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_duplicated(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn n_unique(&self) -> Result<usize, PolarsError>
fn n_unique(&self) -> Result<usize, PolarsError>
ChunkedArray
sourcefn mode(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn mode(&self) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourceimpl ChunkVar<Series> for ChunkedArray<ListType>
impl ChunkVar<Series> for ChunkedArray<ListType>
sourceimpl<T> ChunkVar<Series> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkVar<Series> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceimpl ChunkVar<String> for ChunkedArray<Utf8Type>
impl ChunkVar<String> for ChunkedArray<Utf8Type>
sourceimpl ChunkVar<bool> for ChunkedArray<BooleanType>
impl ChunkVar<bool> for ChunkedArray<BooleanType>
sourceimpl ChunkVar<f32> for ChunkedArray<Float32Type>
impl ChunkVar<f32> for ChunkedArray<Float32Type>
sourceimpl ChunkVar<f64> for ChunkedArray<Float64Type>
impl ChunkVar<f64> for ChunkedArray<Float64Type>
sourceimpl<T> ChunkVar<f64> for ChunkedArray<T>where
T: PolarsIntegerType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> ChunkVar<f64> for ChunkedArray<T>where
T: PolarsIntegerType,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourceimpl ChunkZip<BooleanType> for ChunkedArray<BooleanType>
impl ChunkZip<BooleanType> for ChunkedArray<BooleanType>
sourcefn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<BooleanType>
) -> Result<ChunkedArray<BooleanType>, PolarsError>
true
and values
from other
where the mask evaluates false
Read moresourceimpl ChunkZip<ListType> for ChunkedArray<ListType>
impl ChunkZip<ListType> for ChunkedArray<ListType>
sourcefn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<ListType>
) -> Result<ChunkedArray<ListType>, PolarsError>
fn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<ListType>
) -> Result<ChunkedArray<ListType>, PolarsError>
true
and values
from other
where the mask evaluates false
Read moresourceimpl<T> ChunkZip<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> ChunkZip<ObjectType<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<ObjectType<T>>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
fn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<ObjectType<T>>
) -> Result<ChunkedArray<ObjectType<T>>, PolarsError>
true
and values
from other
where the mask evaluates false
Read moresourceimpl<T> ChunkZip<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> ChunkZip<T> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<T>
) -> Result<ChunkedArray<T>, PolarsError>
fn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<T>
) -> Result<ChunkedArray<T>, PolarsError>
true
and values
from other
where the mask evaluates false
Read moresourceimpl ChunkZip<Utf8Type> for ChunkedArray<Utf8Type>
impl ChunkZip<Utf8Type> for ChunkedArray<Utf8Type>
sourcefn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<Utf8Type>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn zip_with(
&self,
mask: &ChunkedArray<BooleanType>,
other: &ChunkedArray<Utf8Type>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
true
and values
from other
where the mask evaluates false
Read moresourceimpl<'a> ChunkedSet<&'a str> for &'a ChunkedArray<Utf8Type>
impl<'a> ChunkedSet<&'a str> for &'a ChunkedArray<Utf8Type>
fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
V: IntoIterator<Item = Option<&'a str>>,
sourceimpl<T> ChunkedSet<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsOpsNumericType,
ChunkedArray<T>: IntoSeries,
impl<T> ChunkedSet<<T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsOpsNumericType,
ChunkedArray<T>: IntoSeries,
fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
V: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,
sourceimpl ChunkedSet<bool> for &ChunkedArray<BooleanType>
impl ChunkedSet<bool> for &ChunkedArray<BooleanType>
fn set_at_idx2<V>(self, idx: &[u32], values: V) -> Result<Series, PolarsError>where
V: IntoIterator<Item = Option<bool>>,
sourceimpl<T> Clone for ChunkedArray<T>where
T: PolarsDataType,
impl<T> Clone for ChunkedArray<T>where
T: PolarsDataType,
sourcefn clone(&self) -> ChunkedArray<T>
fn clone(&self) -> ChunkedArray<T>
1.0.0 · sourcefn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresourceimpl Debug for ChunkedArray<BooleanType>
impl Debug for ChunkedArray<BooleanType>
sourceimpl Debug for ChunkedArray<ListType>
impl Debug for ChunkedArray<ListType>
sourceimpl<T> Debug for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> Debug for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourceimpl<T> Debug for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Debug for ChunkedArray<T>where
T: PolarsNumericType,
sourceimpl Debug for ChunkedArray<Utf8Type>
impl Debug for ChunkedArray<Utf8Type>
sourceimpl<T> Default for ChunkedArray<T>where
T: PolarsDataType,
impl<T> Default for ChunkedArray<T>where
T: PolarsDataType,
sourcefn default() -> ChunkedArray<T>
fn default() -> ChunkedArray<T>
sourceimpl<T> Div<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Div<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
/
operator.sourcefn div(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Div<&ChunkedArray<T>>>::Output
fn div(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Div<&ChunkedArray<T>>>::Output
/
operation. Read moresourceimpl<T> Div<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Div<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
/
operator.sourcefn div(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Div<ChunkedArray<T>>>::Output
fn div(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Div<ChunkedArray<T>>>::Output
/
operation. Read moresourceimpl<T, N> Div<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Div<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
/
operator.sourceimpl<T, N> Div<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Div<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
/
operator.sourceimpl<T> Drop for ChunkedArray<T>where
T: PolarsDataType,
impl<T> Drop for ChunkedArray<T>where
T: PolarsDataType,
sourceimpl<'a> From<&'a ChunkedArray<BooleanType>> for Vec<Option<bool>, Global>
impl<'a> From<&'a ChunkedArray<BooleanType>> for Vec<Option<bool>, Global>
sourceimpl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<<T as PolarsNumericType>::Native>, Global>where
T: PolarsNumericType,
impl<'a, T> From<&'a ChunkedArray<T>> for Vec<Option<<T as PolarsNumericType>::Native>, Global>where
T: PolarsNumericType,
sourceimpl<'a> From<&'a ChunkedArray<UInt32Type>> for TakeIdx<'a, Once<usize>, Once<Option<usize>>>
impl<'a> From<&'a ChunkedArray<UInt32Type>> for TakeIdx<'a, Once<usize>, Once<Option<usize>>>
Conversion from UInt32Chunked to Unchecked TakeIdx
sourcefn from(
ca: &'a ChunkedArray<UInt32Type>
) -> TakeIdx<'a, Once<usize>, Once<Option<usize>>>
fn from(
ca: &'a ChunkedArray<UInt32Type>
) -> TakeIdx<'a, Once<usize>, Once<Option<usize>>>
sourceimpl<T> From<&[<T as PolarsNumericType>::Native]> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> From<&[<T as PolarsNumericType>::Native]> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from(slice: &[<T as PolarsNumericType>::Native]) -> ChunkedArray<T>
fn from(slice: &[<T as PolarsNumericType>::Native]) -> ChunkedArray<T>
sourceimpl From<(&str, BooleanArray)> for ChunkedArray<BooleanType>
impl From<(&str, BooleanArray)> for ChunkedArray<BooleanType>
sourcefn from(tpl: (&str, BooleanArray)) -> ChunkedArray<BooleanType>
fn from(tpl: (&str, BooleanArray)) -> ChunkedArray<BooleanType>
sourceimpl<T> From<(&str, PrimitiveArray<<T as PolarsNumericType>::Native>)> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> From<(&str, PrimitiveArray<<T as PolarsNumericType>::Native>)> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from(
tpl: (&str, PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>
fn from(
tpl: (&str, PrimitiveArray<<T as PolarsNumericType>::Native>)
) -> ChunkedArray<T>
sourceimpl From<BooleanArray> for ChunkedArray<BooleanType>
impl From<BooleanArray> for ChunkedArray<BooleanType>
sourcefn from(arr: BooleanArray) -> ChunkedArray<BooleanType>
fn from(arr: BooleanArray) -> ChunkedArray<BooleanType>
sourceimpl From<ChunkedArray<BooleanType>> for Vec<Option<bool>, Global>
impl From<ChunkedArray<BooleanType>> for Vec<Option<bool>, Global>
sourceimpl<T> From<ChunkedArray<T>> for Serieswhere
T: PolarsDataType,
ChunkedArray<T>: IntoSeries,
impl<T> From<ChunkedArray<T>> for Serieswhere
T: PolarsDataType,
ChunkedArray<T>: IntoSeries,
sourcefn from(ca: ChunkedArray<T>) -> Series
fn from(ca: ChunkedArray<T>) -> Series
sourceimpl<T> From<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> From<PrimitiveArray<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from(a: PrimitiveArray<<T as PolarsNumericType>::Native>) -> ChunkedArray<T>
fn from(a: PrimitiveArray<<T as PolarsNumericType>::Native>) -> ChunkedArray<T>
sourceimpl<T> FromIterator<(Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> FromIterator<(Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoIterator<Item = (Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)>,
fn from_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoIterator<Item = (Vec<<T as PolarsNumericType>::Native, Global>, Option<Bitmap>)>,
sourceimpl<T> FromIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> FromIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
FromIterator trait
sourcefn from_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,
fn from_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoIterator<Item = Option<<T as PolarsNumericType>::Native>>,
sourceimpl FromIterator<Option<Box<dyn Array + 'static, Global>>> for ChunkedArray<ListType>
impl FromIterator<Option<Box<dyn Array + 'static, Global>>> for ChunkedArray<ListType>
sourcefn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Option<Box<dyn Array + 'static, Global>>>,
fn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Option<Box<dyn Array + 'static, Global>>>,
sourceimpl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str>,
impl<Ptr> FromIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str>,
sourcefn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Option<Ptr>>,
fn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Option<Ptr>>,
sourceimpl FromIterator<Option<Series>> for ChunkedArray<ListType>
impl FromIterator<Option<Series>> for ChunkedArray<ListType>
sourcefn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Option<Series>>,
fn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Option<Series>>,
sourceimpl<T> FromIterator<Option<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> FromIterator<Option<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn from_iter<I>(iter: I) -> ChunkedArray<ObjectType<T>>where
I: IntoIterator<Item = Option<T>>,
fn from_iter<I>(iter: I) -> ChunkedArray<ObjectType<T>>where
I: IntoIterator<Item = Option<T>>,
sourceimpl FromIterator<Option<bool>> for ChunkedArray<BooleanType>
impl FromIterator<Option<bool>> for ChunkedArray<BooleanType>
sourcefn from_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = Option<bool>>,
fn from_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = Option<bool>>,
sourceimpl<Ptr> FromIterator<Ptr> for ChunkedArray<ListType>where
Ptr: Borrow<Series>,
impl<Ptr> FromIterator<Ptr> for ChunkedArray<ListType>where
Ptr: Borrow<Series>,
sourcefn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Ptr>,
fn from_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Ptr>,
sourceimpl<Ptr> FromIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str>,
impl<Ptr> FromIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str>,
sourcefn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Ptr>,
fn from_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Ptr>,
sourceimpl FromIterator<bool> for ChunkedArray<BooleanType>
impl FromIterator<bool> for ChunkedArray<BooleanType>
sourcefn from_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = bool>,
fn from_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = bool>,
sourceimpl<T> FromIteratorReversed<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
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>>,
sourceimpl FromIteratorReversed<Option<bool>> for ChunkedArray<BooleanType>
impl FromIteratorReversed<Option<bool>> for ChunkedArray<BooleanType>
fn from_trusted_len_iter_rev<I>(iter: I) -> ChunkedArray<BooleanType>where
I: TrustedLen<Item = Option<bool>>,
sourceimpl<T> FromParallelIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> FromParallelIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from_par_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoParallelIterator<Item = Option<<T as PolarsNumericType>::Native>>,
fn from_par_iter<I>(iter: I) -> ChunkedArray<T>where
I: IntoParallelIterator<Item = Option<<T as PolarsNumericType>::Native>>,
par_iter
. Read moresourceimpl<Ptr> FromParallelIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str> + Send + Sync,
impl<Ptr> FromParallelIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str> + Send + Sync,
sourcefn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoParallelIterator<Item = Option<Ptr>>,
fn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoParallelIterator<Item = Option<Ptr>>,
par_iter
. Read moresourceimpl FromParallelIterator<Option<Series>> for ChunkedArray<ListType>
impl FromParallelIterator<Option<Series>> for ChunkedArray<ListType>
sourcefn from_par_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoParallelIterator<Item = Option<Series>>,
fn from_par_iter<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoParallelIterator<Item = Option<Series>>,
par_iter
. Read moresourceimpl<Ptr> FromParallelIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str> + Send + Sync,
impl<Ptr> FromParallelIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str> + Send + Sync,
sourcefn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoParallelIterator<Item = Ptr>,
fn from_par_iter<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoParallelIterator<Item = Ptr>,
par_iter
. Read moresourceimpl FromParallelIterator<bool> for ChunkedArray<BooleanType>
impl FromParallelIterator<bool> for ChunkedArray<BooleanType>
sourcefn from_par_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoParallelIterator<Item = bool>,
fn from_par_iter<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoParallelIterator<Item = bool>,
par_iter
. Read moresourceimpl<T> FromTrustedLenIterator<Option<<T as PolarsNumericType>::Native>> for ChunkedArray<T>where
T: PolarsNumericType,
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>>,
sourceimpl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str>,
impl<Ptr> FromTrustedLenIterator<Option<Ptr>> for ChunkedArray<Utf8Type>where
Ptr: AsRef<str>,
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Option<Ptr>>,
sourceimpl FromTrustedLenIterator<Option<Series>> for ChunkedArray<ListType>
impl FromTrustedLenIterator<Option<Series>> for ChunkedArray<ListType>
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Option<Series>>,
sourceimpl<T> FromTrustedLenIterator<Option<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> FromTrustedLenIterator<Option<T>> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ObjectType<T>>where
I: IntoIterator<Item = Option<T>>,
sourceimpl FromTrustedLenIterator<Option<bool>> for ChunkedArray<BooleanType>
impl FromTrustedLenIterator<Option<bool>> for ChunkedArray<BooleanType>
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = Option<bool>>,
<I as IntoIterator>::IntoIter: TrustedLen,
sourceimpl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<ListType>where
Ptr: Borrow<Series>,
impl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<ListType>where
Ptr: Borrow<Series>,
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<ListType>where
I: IntoIterator<Item = Ptr>,
sourceimpl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str>,
impl<Ptr> FromTrustedLenIterator<Ptr> for ChunkedArray<Utf8Type>where
Ptr: PolarsAsRef<str>,
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<Utf8Type>where
I: IntoIterator<Item = Ptr>,
sourceimpl FromTrustedLenIterator<bool> for ChunkedArray<BooleanType>
impl FromTrustedLenIterator<bool> for ChunkedArray<BooleanType>
fn from_iter_trusted_length<I>(iter: I) -> ChunkedArray<BooleanType>where
I: IntoIterator<Item = bool>,
<I as IntoIterator>::IntoIter: TrustedLen,
sourceimpl Interpolate for ChunkedArray<Float32Type>
impl Interpolate for ChunkedArray<Float32Type>
fn interpolate(&self) -> ChunkedArray<Float32Type>
sourceimpl Interpolate for ChunkedArray<Float64Type>
impl Interpolate for ChunkedArray<Float64Type>
fn interpolate(&self) -> ChunkedArray<Float64Type>
sourceimpl Interpolate for ChunkedArray<Int16Type>
impl Interpolate for ChunkedArray<Int16Type>
fn interpolate(&self) -> ChunkedArray<Int16Type>
sourceimpl Interpolate for ChunkedArray<Int32Type>
impl Interpolate for ChunkedArray<Int32Type>
fn interpolate(&self) -> ChunkedArray<Int32Type>
sourceimpl Interpolate for ChunkedArray<Int64Type>
impl Interpolate for ChunkedArray<Int64Type>
fn interpolate(&self) -> ChunkedArray<Int64Type>
sourceimpl Interpolate for ChunkedArray<Int8Type>
impl Interpolate for ChunkedArray<Int8Type>
fn interpolate(&self) -> ChunkedArray<Int8Type>
sourceimpl Interpolate for ChunkedArray<UInt16Type>
impl Interpolate for ChunkedArray<UInt16Type>
fn interpolate(&self) -> ChunkedArray<UInt16Type>
sourceimpl Interpolate for ChunkedArray<UInt32Type>
impl Interpolate for ChunkedArray<UInt32Type>
fn interpolate(&self) -> ChunkedArray<UInt32Type>
sourceimpl Interpolate for ChunkedArray<UInt64Type>
impl Interpolate for ChunkedArray<UInt64Type>
fn interpolate(&self) -> ChunkedArray<UInt64Type>
sourceimpl Interpolate for ChunkedArray<UInt8Type>
impl Interpolate for ChunkedArray<UInt8Type>
fn interpolate(&self) -> ChunkedArray<UInt8Type>
sourceimpl IntoGroupsProxy for ChunkedArray<BooleanType>
impl IntoGroupsProxy for ChunkedArray<BooleanType>
sourcefn group_tuples(
&self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
fn group_tuples(
&self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
sourceimpl IntoGroupsProxy for ChunkedArray<ListType>
impl IntoGroupsProxy for ChunkedArray<ListType>
sourcefn group_tuples(
&'a self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
fn group_tuples(
&'a self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
sourceimpl<T> IntoGroupsProxy for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> IntoGroupsProxy for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn group_tuples(
&self,
_multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
fn group_tuples(
&self,
_multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
sourceimpl<T> IntoGroupsProxy for ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: NumCast,
impl<T> IntoGroupsProxy for ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: NumCast,
sourcefn group_tuples(
&self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
fn group_tuples(
&self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
sourceimpl IntoGroupsProxy for ChunkedArray<Utf8Type>
impl IntoGroupsProxy for ChunkedArray<Utf8Type>
sourcefn group_tuples(
&'a self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
fn group_tuples(
&'a self,
multithreaded: bool,
sorted: bool
) -> Result<GroupsProxy, PolarsError>
sourceimpl<'a> IntoIterator for &'a ChunkedArray<BooleanType>
impl<'a> IntoIterator for &'a ChunkedArray<BooleanType>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BooleanType> as IntoIterator>::Item> + 'a, Global>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BooleanType> as IntoIterator>::Item> + 'a, Global>
sourcefn into_iter(self) -> <&'a ChunkedArray<BooleanType> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a ChunkedArray<BooleanType> as IntoIterator>::IntoIter
sourceimpl<'a> IntoIterator for &'a ChunkedArray<ListType>
impl<'a> IntoIterator for &'a ChunkedArray<ListType>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ListType> as IntoIterator>::Item> + 'a, Global>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ListType> as IntoIterator>::Item> + 'a, Global>
sourcefn into_iter(self) -> <&'a ChunkedArray<ListType> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a ChunkedArray<ListType> as IntoIterator>::IntoIter
sourceimpl<'a, T> IntoIterator for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<'a, T> IntoIterator for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::Item> + 'a, Global>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::Item> + 'a, Global>
sourcefn into_iter(
self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::IntoIter
fn into_iter(
self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoIterator>::IntoIter
sourceimpl<'a, T> IntoIterator for &'a ChunkedArray<T>where
T: PolarsNumericType,
impl<'a, T> IntoIterator for &'a ChunkedArray<T>where
T: PolarsNumericType,
type Item = Option<<T as PolarsNumericType>::Native>
type Item = Option<<T as PolarsNumericType>::Native>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<T> as IntoIterator>::Item> + 'a, Global>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<T> as IntoIterator>::Item> + 'a, Global>
sourcefn into_iter(self) -> <&'a ChunkedArray<T> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a ChunkedArray<T> as IntoIterator>::IntoIter
sourceimpl<'a> IntoIterator for &'a ChunkedArray<Utf8Type>
impl<'a> IntoIterator for &'a ChunkedArray<Utf8Type>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<Utf8Type> as IntoIterator>::Item> + 'a, Global>
type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<Utf8Type> as IntoIterator>::Item> + 'a, Global>
sourcefn into_iter(self) -> <&'a ChunkedArray<Utf8Type> as IntoIterator>::IntoIter
fn into_iter(self) -> <&'a ChunkedArray<Utf8Type> as IntoIterator>::IntoIter
sourceimpl<T> IntoSeries for ChunkedArray<T>where
T: 'static + PolarsDataType,
SeriesWrap<ChunkedArray<T>>: SeriesTrait,
impl<T> IntoSeries for ChunkedArray<T>where
T: 'static + PolarsDataType,
SeriesWrap<ChunkedArray<T>>: SeriesTrait,
fn into_series(self) -> Serieswhere
ChunkedArray<T>: Sized,
fn is_series() -> bool
sourceimpl<T> IntoSeriesOps for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: NumericNative,
impl<T> IntoSeriesOps for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: NumericNative,
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl<T> IntoSeriesOps for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: NumericNative,
impl<T> IntoSeriesOps for &ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: NumericNative,
sourceimpl IntoSeriesOps for ChunkedArray<BooleanType>
impl IntoSeriesOps for ChunkedArray<BooleanType>
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl IntoSeriesOps for ChunkedArray<BooleanType>
impl IntoSeriesOps for ChunkedArray<BooleanType>
sourceimpl IntoSeriesOps for ChunkedArray<Float32Type>
impl IntoSeriesOps for ChunkedArray<Float32Type>
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl IntoSeriesOps for ChunkedArray<Float32Type>
impl IntoSeriesOps for ChunkedArray<Float32Type>
sourceimpl IntoSeriesOps for ChunkedArray<Float64Type>
impl IntoSeriesOps for ChunkedArray<Float64Type>
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl IntoSeriesOps for ChunkedArray<Float64Type>
impl IntoSeriesOps for ChunkedArray<Float64Type>
sourceimpl IntoSeriesOps for ChunkedArray<ListType>
impl IntoSeriesOps for ChunkedArray<ListType>
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl IntoSeriesOps for ChunkedArray<ListType>
impl IntoSeriesOps for ChunkedArray<ListType>
sourceimpl IntoSeriesOps for ChunkedArray<Utf8Type>
impl IntoSeriesOps for ChunkedArray<Utf8Type>
fn to_ops(&self) -> Arc<dyn SeriesOpsTime + 'static>
sourceimpl IntoSeriesOps for ChunkedArray<Utf8Type>
impl IntoSeriesOps for ChunkedArray<Utf8Type>
sourceimpl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<BooleanType>
impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<BooleanType>
type Item = bool
type TakeRandom = TakeRandBranch2<BoolTakeRandomSingleChunk<'a>, BoolTakeRandom<'a>>
sourcefn take_rand(
&self
) -> <&'a ChunkedArray<BooleanType> as IntoTakeRandom<'a>>::TakeRandom
fn take_rand(
&self
) -> <&'a ChunkedArray<BooleanType> as IntoTakeRandom<'a>>::TakeRandom
TakeRandom
.sourceimpl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<ListType>
impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<ListType>
type Item = Series
type TakeRandom = TakeRandBranch2<ListTakeRandomSingleChunk<'a>, ListTakeRandom<'a>>
sourcefn take_rand(
&self
) -> <&'a ChunkedArray<ListType> as IntoTakeRandom<'a>>::TakeRandom
fn take_rand(
&self
) -> <&'a ChunkedArray<ListType> as IntoTakeRandom<'a>>::TakeRandom
TakeRandom
.sourceimpl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
type Item = &'a T
type TakeRandom = TakeRandBranch2<ObjectTakeRandomSingleChunk<'a, T>, ObjectTakeRandom<'a, T>>
sourcefn take_rand(
&self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoTakeRandom<'a>>::TakeRandom
fn take_rand(
&self
) -> <&'a ChunkedArray<ObjectType<T>> as IntoTakeRandom<'a>>::TakeRandom
TakeRandom
.sourceimpl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<T>where
T: PolarsNumericType,
impl<'a, T> IntoTakeRandom<'a> for &'a ChunkedArray<T>where
T: PolarsNumericType,
type Item = <T as PolarsNumericType>::Native
type TakeRandom = TakeRandBranch3<NumTakeRandomCont<'a, <T as PolarsNumericType>::Native>, NumTakeRandomSingleChunk<'a, <T as PolarsNumericType>::Native>, NumTakeRandomChunked<'a, <T as PolarsNumericType>::Native>>
sourcefn take_rand(&self) -> <&'a ChunkedArray<T> as IntoTakeRandom<'a>>::TakeRandom
fn take_rand(&self) -> <&'a ChunkedArray<T> as IntoTakeRandom<'a>>::TakeRandom
TakeRandom
.sourceimpl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<Utf8Type>
impl<'a> IntoTakeRandom<'a> for &'a ChunkedArray<Utf8Type>
type Item = &'a str
type TakeRandom = TakeRandBranch2<Utf8TakeRandomSingleChunk<'a>, Utf8TakeRandom<'a>>
sourcefn take_rand(
&self
) -> <&'a ChunkedArray<Utf8Type> as IntoTakeRandom<'a>>::TakeRandom
fn take_rand(
&self
) -> <&'a ChunkedArray<Utf8Type> as IntoTakeRandom<'a>>::TakeRandom
TakeRandom
.sourceimpl<T> IsFirst<T> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> IsFirst<T> for ChunkedArray<T>where
T: PolarsNumericType,
fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl IsFirst<Utf8Type> for ChunkedArray<Utf8Type>
impl IsFirst<Utf8Type> for ChunkedArray<Utf8Type>
fn is_first(&self) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl IsIn for ChunkedArray<BooleanType>
impl IsIn for ChunkedArray<BooleanType>
sourcefn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl<T> IsIn for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> IsIn for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl IsIn for ChunkedArray<Utf8Type>
impl IsIn for ChunkedArray<Utf8Type>
sourcefn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn is_in(&self, other: &Series) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourceimpl ListNameSpaceImpl for ChunkedArray<ListType>
impl ListNameSpaceImpl for ChunkedArray<ListType>
sourcefn lst_join(
&self,
separator: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn lst_join(
&self,
separator: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
DataType::Utf8
, the individual items will be joined into a
single string separated by separator
. Read morefn lst_max(&self) -> Series
fn lst_min(&self) -> Series
fn lst_sum(&self) -> Series
fn lst_mean(&self) -> ChunkedArray<Float64Type>
fn lst_sort(&self, reverse: bool) -> ChunkedArray<ListType>
fn lst_reverse(&self) -> ChunkedArray<ListType>
fn lst_unique(&self) -> Result<ChunkedArray<ListType>, PolarsError>
fn lst_arg_min(&self) -> ChunkedArray<UInt32Type>
fn lst_arg_max(&self) -> ChunkedArray<UInt32Type>
fn lst_diff(
&self,
n: usize,
null_behavior: NullBehavior
) -> ChunkedArray<ListType>
fn lst_shift(&self, periods: i64) -> ChunkedArray<ListType>
fn lst_slice(&self, offset: i64, length: usize) -> ChunkedArray<ListType>
fn lst_lengths(&self) -> ChunkedArray<UInt32Type>
sourcefn lst_get(&self, idx: i64) -> Result<Series, PolarsError>
fn lst_get(&self, idx: i64) -> Result<Series, PolarsError>
0
would return the first item of every sublist
and index -1
would return the last item of every sublist
if an index is out of bounds, it will return a None
. Read morefn lst_concat(
&self,
other: &[Series]
) -> Result<ChunkedArray<ListType>, PolarsError>
sourceimpl<T> Mul<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Mul<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
*
operator.sourcefn mul(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Mul<&ChunkedArray<T>>>::Output
fn mul(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Mul<&ChunkedArray<T>>>::Output
*
operation. Read moresourceimpl<T> Mul<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Mul<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
*
operator.sourcefn mul(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Mul<ChunkedArray<T>>>::Output
fn mul(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Mul<ChunkedArray<T>>>::Output
*
operation. Read moresourceimpl<T, N> Mul<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Mul<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
*
operator.sourceimpl<T, N> Mul<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Mul<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
*
operator.sourceimpl<T> NamedFrom<&[T], &[T]> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> NamedFrom<&[T], &[T]> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn new(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>
fn new(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>
sourceimpl NamedFrom<Range<u32>, UInt32Type> for ChunkedArray<UInt32Type>
impl NamedFrom<Range<u32>, UInt32Type> for ChunkedArray<UInt32Type>
sourcefn new(name: &str, range: Range<u32>) -> ChunkedArray<UInt32Type>
fn new(name: &str, range: Range<u32>) -> ChunkedArray<UInt32Type>
sourceimpl NamedFrom<Range<u64>, UInt64Type> for ChunkedArray<UInt64Type>
impl NamedFrom<Range<u64>, UInt64Type> for ChunkedArray<UInt64Type>
sourcefn new(name: &str, range: Range<u64>) -> ChunkedArray<UInt64Type>
fn new(name: &str, range: Range<u64>) -> ChunkedArray<UInt64Type>
sourceimpl<T, S> NamedFrom<S, [Option<T>]> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
S: AsRef<[Option<T>]>,
impl<T, S> NamedFrom<S, [Option<T>]> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
S: AsRef<[Option<T>]>,
sourcefn new(name: &str, v: S) -> ChunkedArray<ObjectType<T>>
fn new(name: &str, v: S) -> ChunkedArray<ObjectType<T>>
sourceimpl<'a, T> NamedFrom<T, [&'a str]> for ChunkedArray<Utf8Type>where
T: AsRef<[&'a str]>,
impl<'a, T> NamedFrom<T, [&'a str]> for ChunkedArray<Utf8Type>where
T: AsRef<[&'a str]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<'a, T> NamedFrom<T, [Cow<'a, str>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Cow<'a, str>]>,
impl<'a, T> NamedFrom<T, [Cow<'a, str>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Cow<'a, str>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<'a, T> NamedFrom<T, [Option<&'a str>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<&'a str>]>,
impl<'a, T> NamedFrom<T, [Option<&'a str>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<&'a str>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<'a, T> NamedFrom<T, [Option<Cow<'a, str>>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<Cow<'a, str>>]>,
impl<'a, T> NamedFrom<T, [Option<Cow<'a, str>>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<Cow<'a, str>>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<T> NamedFrom<T, [Option<String>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<String>]>,
impl<T> NamedFrom<T, [Option<String>]> for ChunkedArray<Utf8Type>where
T: AsRef<[Option<String>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<T> NamedFrom<T, [Option<bool>]> for ChunkedArray<BooleanType>where
T: AsRef<[Option<bool>]>,
impl<T> NamedFrom<T, [Option<bool>]> for ChunkedArray<BooleanType>where
T: AsRef<[Option<bool>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<BooleanType>
fn new(name: &str, v: T) -> ChunkedArray<BooleanType>
sourceimpl<T> NamedFrom<T, [Option<f32>]> for ChunkedArray<Float32Type>where
T: AsRef<[Option<f32>]>,
impl<T> NamedFrom<T, [Option<f32>]> for ChunkedArray<Float32Type>where
T: AsRef<[Option<f32>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Float32Type>
fn new(name: &str, v: T) -> ChunkedArray<Float32Type>
sourceimpl<T> NamedFrom<T, [Option<f64>]> for ChunkedArray<Float64Type>where
T: AsRef<[Option<f64>]>,
impl<T> NamedFrom<T, [Option<f64>]> for ChunkedArray<Float64Type>where
T: AsRef<[Option<f64>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Float64Type>
fn new(name: &str, v: T) -> ChunkedArray<Float64Type>
sourceimpl<T> NamedFrom<T, [Option<i16>]> for ChunkedArray<Int16Type>where
T: AsRef<[Option<i16>]>,
impl<T> NamedFrom<T, [Option<i16>]> for ChunkedArray<Int16Type>where
T: AsRef<[Option<i16>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int16Type>
fn new(name: &str, v: T) -> ChunkedArray<Int16Type>
sourceimpl<T> NamedFrom<T, [Option<i32>]> for ChunkedArray<Int32Type>where
T: AsRef<[Option<i32>]>,
impl<T> NamedFrom<T, [Option<i32>]> for ChunkedArray<Int32Type>where
T: AsRef<[Option<i32>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int32Type>
fn new(name: &str, v: T) -> ChunkedArray<Int32Type>
sourceimpl<T> NamedFrom<T, [Option<i64>]> for ChunkedArray<Int64Type>where
T: AsRef<[Option<i64>]>,
impl<T> NamedFrom<T, [Option<i64>]> for ChunkedArray<Int64Type>where
T: AsRef<[Option<i64>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int64Type>
fn new(name: &str, v: T) -> ChunkedArray<Int64Type>
sourceimpl<T> NamedFrom<T, [Option<i8>]> for ChunkedArray<Int8Type>where
T: AsRef<[Option<i8>]>,
impl<T> NamedFrom<T, [Option<i8>]> for ChunkedArray<Int8Type>where
T: AsRef<[Option<i8>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int8Type>
fn new(name: &str, v: T) -> ChunkedArray<Int8Type>
sourceimpl<T> NamedFrom<T, [Option<u16>]> for ChunkedArray<UInt16Type>where
T: AsRef<[Option<u16>]>,
impl<T> NamedFrom<T, [Option<u16>]> for ChunkedArray<UInt16Type>where
T: AsRef<[Option<u16>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt16Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt16Type>
sourceimpl<T> NamedFrom<T, [Option<u32>]> for ChunkedArray<UInt32Type>where
T: AsRef<[Option<u32>]>,
impl<T> NamedFrom<T, [Option<u32>]> for ChunkedArray<UInt32Type>where
T: AsRef<[Option<u32>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt32Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt32Type>
sourceimpl<T> NamedFrom<T, [Option<u64>]> for ChunkedArray<UInt64Type>where
T: AsRef<[Option<u64>]>,
impl<T> NamedFrom<T, [Option<u64>]> for ChunkedArray<UInt64Type>where
T: AsRef<[Option<u64>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt64Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt64Type>
sourceimpl<T> NamedFrom<T, [Option<u8>]> for ChunkedArray<UInt8Type>where
T: AsRef<[Option<u8>]>,
impl<T> NamedFrom<T, [Option<u8>]> for ChunkedArray<UInt8Type>where
T: AsRef<[Option<u8>]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt8Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt8Type>
sourceimpl<T> NamedFrom<T, [String]> for ChunkedArray<Utf8Type>where
T: AsRef<[String]>,
impl<T> NamedFrom<T, [String]> for ChunkedArray<Utf8Type>where
T: AsRef<[String]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
fn new(name: &str, v: T) -> ChunkedArray<Utf8Type>
sourceimpl<T> NamedFrom<T, [bool]> for ChunkedArray<BooleanType>where
T: AsRef<[bool]>,
impl<T> NamedFrom<T, [bool]> for ChunkedArray<BooleanType>where
T: AsRef<[bool]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<BooleanType>
fn new(name: &str, v: T) -> ChunkedArray<BooleanType>
sourceimpl<T> NamedFrom<T, [f32]> for ChunkedArray<Float32Type>where
T: AsRef<[f32]>,
impl<T> NamedFrom<T, [f32]> for ChunkedArray<Float32Type>where
T: AsRef<[f32]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Float32Type>
fn new(name: &str, v: T) -> ChunkedArray<Float32Type>
sourceimpl<T> NamedFrom<T, [f64]> for ChunkedArray<Float64Type>where
T: AsRef<[f64]>,
impl<T> NamedFrom<T, [f64]> for ChunkedArray<Float64Type>where
T: AsRef<[f64]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Float64Type>
fn new(name: &str, v: T) -> ChunkedArray<Float64Type>
sourceimpl<T> NamedFrom<T, [i16]> for ChunkedArray<Int16Type>where
T: AsRef<[i16]>,
impl<T> NamedFrom<T, [i16]> for ChunkedArray<Int16Type>where
T: AsRef<[i16]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int16Type>
fn new(name: &str, v: T) -> ChunkedArray<Int16Type>
sourceimpl<T> NamedFrom<T, [i32]> for ChunkedArray<Int32Type>where
T: AsRef<[i32]>,
impl<T> NamedFrom<T, [i32]> for ChunkedArray<Int32Type>where
T: AsRef<[i32]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int32Type>
fn new(name: &str, v: T) -> ChunkedArray<Int32Type>
sourceimpl<T> NamedFrom<T, [i64]> for ChunkedArray<Int64Type>where
T: AsRef<[i64]>,
impl<T> NamedFrom<T, [i64]> for ChunkedArray<Int64Type>where
T: AsRef<[i64]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int64Type>
fn new(name: &str, v: T) -> ChunkedArray<Int64Type>
sourceimpl<T> NamedFrom<T, [i8]> for ChunkedArray<Int8Type>where
T: AsRef<[i8]>,
impl<T> NamedFrom<T, [i8]> for ChunkedArray<Int8Type>where
T: AsRef<[i8]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<Int8Type>
fn new(name: &str, v: T) -> ChunkedArray<Int8Type>
sourceimpl<T> NamedFrom<T, [u16]> for ChunkedArray<UInt16Type>where
T: AsRef<[u16]>,
impl<T> NamedFrom<T, [u16]> for ChunkedArray<UInt16Type>where
T: AsRef<[u16]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt16Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt16Type>
sourceimpl<T> NamedFrom<T, [u32]> for ChunkedArray<UInt32Type>where
T: AsRef<[u32]>,
impl<T> NamedFrom<T, [u32]> for ChunkedArray<UInt32Type>where
T: AsRef<[u32]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt32Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt32Type>
sourceimpl<T> NamedFrom<T, [u64]> for ChunkedArray<UInt64Type>where
T: AsRef<[u64]>,
impl<T> NamedFrom<T, [u64]> for ChunkedArray<UInt64Type>where
T: AsRef<[u64]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt64Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt64Type>
sourceimpl<T> NamedFrom<T, [u8]> for ChunkedArray<UInt8Type>where
T: AsRef<[u8]>,
impl<T> NamedFrom<T, [u8]> for ChunkedArray<UInt8Type>where
T: AsRef<[u8]>,
sourcefn new(name: &str, v: T) -> ChunkedArray<UInt8Type>
fn new(name: &str, v: T) -> ChunkedArray<UInt8Type>
sourceimpl NewChunkedArray<BooleanType, bool> for ChunkedArray<BooleanType>
impl NewChunkedArray<BooleanType, bool> for ChunkedArray<BooleanType>
sourcefn from_iter_values(
name: &str,
it: impl Iterator<Item = bool>
) -> ChunkedArray<BooleanType>
fn from_iter_values(
name: &str,
it: impl Iterator<Item = bool>
) -> ChunkedArray<BooleanType>
Create a new ChunkedArray from an iterator.
fn from_slice(name: &str, v: &[bool]) -> ChunkedArray<BooleanType>
fn from_slice_options(
name: &str,
opt_v: &[Option<bool>]
) -> ChunkedArray<BooleanType>
sourcefn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<bool>>
) -> ChunkedArray<BooleanType>
fn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<bool>>
) -> ChunkedArray<BooleanType>
sourceimpl<T> NewChunkedArray<ObjectType<T>, T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> NewChunkedArray<ObjectType<T>, T> for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn from_iter_values(
name: &str,
it: impl Iterator<Item = T>
) -> ChunkedArray<ObjectType<T>>
fn from_iter_values(
name: &str,
it: impl Iterator<Item = T>
) -> ChunkedArray<ObjectType<T>>
Create a new ChunkedArray from an iterator.
fn from_slice(name: &str, v: &[T]) -> ChunkedArray<ObjectType<T>>
fn from_slice_options(
name: &str,
opt_v: &[Option<T>]
) -> ChunkedArray<ObjectType<T>>
sourcefn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<T>>
) -> ChunkedArray<ObjectType<T>>
fn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<T>>
) -> ChunkedArray<ObjectType<T>>
sourceimpl<T> NewChunkedArray<T, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> NewChunkedArray<T, <T as PolarsNumericType>::Native> for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn from_iter_values(
name: &str,
it: impl Iterator<Item = <T as PolarsNumericType>::Native>
) -> ChunkedArray<T>
fn from_iter_values(
name: &str,
it: impl Iterator<Item = <T as PolarsNumericType>::Native>
) -> ChunkedArray<T>
Create a new ChunkedArray from an iterator.
fn from_slice(
name: &str,
v: &[<T as PolarsNumericType>::Native]
) -> ChunkedArray<T>
fn from_slice_options(
name: &str,
opt_v: &[Option<<T as PolarsNumericType>::Native>]
) -> ChunkedArray<T>
sourcefn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<<T as PolarsNumericType>::Native>>
) -> ChunkedArray<T>
fn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<<T as PolarsNumericType>::Native>>
) -> ChunkedArray<T>
sourceimpl<S> NewChunkedArray<Utf8Type, S> for ChunkedArray<Utf8Type>where
S: AsRef<str>,
impl<S> NewChunkedArray<Utf8Type, S> for ChunkedArray<Utf8Type>where
S: AsRef<str>,
sourcefn from_iter_values(
name: &str,
it: impl Iterator<Item = S>
) -> ChunkedArray<Utf8Type>
fn from_iter_values(
name: &str,
it: impl Iterator<Item = S>
) -> ChunkedArray<Utf8Type>
Create a new ChunkedArray from an iterator.
fn from_slice(name: &str, v: &[S]) -> ChunkedArray<Utf8Type>
fn from_slice_options(name: &str, opt_v: &[Option<S>]) -> ChunkedArray<Utf8Type>
sourcefn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<S>>
) -> ChunkedArray<Utf8Type>
fn from_iter_options(
name: &str,
it: impl Iterator<Item = Option<S>>
) -> ChunkedArray<Utf8Type>
sourceimpl Not for &ChunkedArray<BooleanType>
impl Not for &ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
!
operator.sourcefn not(self) -> <&ChunkedArray<BooleanType> as Not>::Output
fn not(self) -> <&ChunkedArray<BooleanType> as Not>::Output
!
operation. Read moresourceimpl Not for ChunkedArray<BooleanType>
impl Not for ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
type Output = ChunkedArray<BooleanType>
!
operator.sourcefn not(self) -> <ChunkedArray<BooleanType> as Not>::Output
fn not(self) -> <ChunkedArray<BooleanType> as Not>::Output
!
operation. Read moresourceimpl<T> NumOpsDispatch for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
impl<T> NumOpsDispatch for ChunkedArray<T>where
T: PolarsNumericType,
ChunkedArray<T>: IntoSeries,
fn subtract(&self, rhs: &Series) -> Result<Series, PolarsError>
fn add_to(&self, rhs: &Series) -> Result<Series, PolarsError>
fn multiply(&self, rhs: &Series) -> Result<Series, PolarsError>
fn divide(&self, rhs: &Series) -> Result<Series, PolarsError>
fn remainder(&self, rhs: &Series) -> Result<Series, PolarsError>
sourceimpl NumOpsDispatch for ChunkedArray<Utf8Type>
impl NumOpsDispatch for ChunkedArray<Utf8Type>
fn add_to(&self, rhs: &Series) -> Result<Series, PolarsError>
fn subtract(&self, rhs: &Series) -> Result<Series, PolarsError>
fn multiply(&self, rhs: &Series) -> Result<Series, PolarsError>
fn divide(&self, rhs: &Series) -> Result<Series, PolarsError>
fn remainder(&self, rhs: &Series) -> Result<Series, PolarsError>
sourceimpl NumOpsDispatchChecked for ChunkedArray<Float32Type>
impl NumOpsDispatchChecked for ChunkedArray<Float32Type>
sourcefn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div_num<T>(&self, _rhs: T) -> Result<Series, PolarsError>where
T: ToPrimitive,
sourceimpl NumOpsDispatchChecked for ChunkedArray<Float64Type>
impl NumOpsDispatchChecked for ChunkedArray<Float64Type>
sourcefn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div_num<T>(&self, _rhs: T) -> Result<Series, PolarsError>where
T: ToPrimitive,
sourceimpl<T> NumOpsDispatchChecked for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: CheckedDiv,
<T as PolarsNumericType>::Native: CheckedDiv,
<T as PolarsNumericType>::Native: Zero,
<T as PolarsNumericType>::Native: One,
ChunkedArray<T>: IntoSeries,
<<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
<<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
impl<T> NumOpsDispatchChecked for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: CheckedDiv,
<T as PolarsNumericType>::Native: CheckedDiv,
<T as PolarsNumericType>::Native: Zero,
<T as PolarsNumericType>::Native: One,
ChunkedArray<T>: IntoSeries,
<<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
<<T as PolarsNumericType>::Native as Div<<T as PolarsNumericType>::Native>>::Output == <T as PolarsNumericType>::Native,
sourcefn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div(&self, rhs: &Series) -> Result<Series, PolarsError>
fn checked_div_num<T>(&self, _rhs: T) -> Result<Series, PolarsError>where
T: ToPrimitive,
sourceimpl QuantileAggSeries for ChunkedArray<BooleanType>
impl QuantileAggSeries for ChunkedArray<BooleanType>
sourcefn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl QuantileAggSeries for ChunkedArray<Float32Type>
impl QuantileAggSeries for ChunkedArray<Float32Type>
sourcefn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl QuantileAggSeries for ChunkedArray<Float64Type>
impl QuantileAggSeries for ChunkedArray<Float64Type>
sourcefn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl QuantileAggSeries for ChunkedArray<ListType>
impl QuantileAggSeries for ChunkedArray<ListType>
sourcefn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl<T> QuantileAggSeries for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<T> QuantileAggSeries for ChunkedArray<ObjectType<T>>where
T: PolarsObject,
sourcefn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl<T> QuantileAggSeries for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Ord,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
impl<T> QuantileAggSeries for ChunkedArray<T>where
T: PolarsIntegerType,
<T as PolarsNumericType>::Native: Ord,
<<T as PolarsNumericType>::Native as Simd>::Simd: Add<<<T as PolarsNumericType>::Native as Simd>::Simd>,
<<T as PolarsNumericType>::Native as Simd>::Simd: Sum<<T as PolarsNumericType>::Native>,
<<T as PolarsNumericType>::Native as Simd>::Simd: SimdOrd<<T as PolarsNumericType>::Native>,
<<<T as PolarsNumericType>::Native as Simd>::Simd as Add<<<T as PolarsNumericType>::Native as Simd>::Simd>>::Output == <<T as PolarsNumericType>::Native as Simd>::Simd,
sourcefn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
quantile: f64,
interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl QuantileAggSeries for ChunkedArray<Utf8Type>
impl QuantileAggSeries for ChunkedArray<Utf8Type>
sourcefn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
fn quantile_as_series(
&self,
_quantile: f64,
_interpol: QuantileInterpolOptions
) -> Result<Series, PolarsError>
sourcefn median_as_series(&self) -> Series
fn median_as_series(&self) -> Series
sourceimpl<T> Rem<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Rem<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
%
operator.sourcefn rem(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Rem<&ChunkedArray<T>>>::Output
fn rem(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Rem<&ChunkedArray<T>>>::Output
%
operation. Read moresourceimpl<T> Rem<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Rem<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
%
operator.sourcefn rem(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Rem<ChunkedArray<T>>>::Output
fn rem(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Rem<ChunkedArray<T>>>::Output
%
operation. Read moresourceimpl<T, N> Rem<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Rem<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
%
operator.sourceimpl<T, N> Rem<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Rem<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
%
operator.sourceimpl RepeatBy for ChunkedArray<BooleanType>
impl RepeatBy for ChunkedArray<BooleanType>
sourcefn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
n
times, where n
is determined by the values in by
.sourceimpl<T> RepeatBy for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> RepeatBy for ChunkedArray<T>where
T: PolarsNumericType,
sourcefn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
n
times, where n
is determined by the values in by
.sourceimpl RepeatBy for ChunkedArray<Utf8Type>
impl RepeatBy for ChunkedArray<Utf8Type>
sourcefn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
fn repeat_by(&self, by: &ChunkedArray<UInt32Type>) -> ChunkedArray<ListType>
n
times, where n
is determined by the values in by
.sourceimpl<T> StrConcat for ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Display,
impl<T> StrConcat for ChunkedArray<T>where
T: PolarsNumericType,
<T as PolarsNumericType>::Native: Display,
sourcefn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>
fn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>
sourceimpl StrConcat for ChunkedArray<Utf8Type>
impl StrConcat for ChunkedArray<Utf8Type>
sourcefn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>
fn str_concat(&self, delimiter: &str) -> ChunkedArray<Utf8Type>
sourceimpl<T> Sub<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Sub<&ChunkedArray<T>> for &ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
-
operator.sourcefn sub(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Sub<&ChunkedArray<T>>>::Output
fn sub(
self,
rhs: &ChunkedArray<T>
) -> <&ChunkedArray<T> as Sub<&ChunkedArray<T>>>::Output
-
operation. Read moresourceimpl<T> Sub<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> Sub<ChunkedArray<T>> for ChunkedArray<T>where
T: PolarsNumericType,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
-
operator.sourcefn sub(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Sub<ChunkedArray<T>>>::Output
fn sub(
self,
rhs: ChunkedArray<T>
) -> <ChunkedArray<T> as Sub<ChunkedArray<T>>>::Output
-
operation. Read moresourceimpl<T, N> Sub<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Sub<N> for &ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
-
operator.sourceimpl<T, N> Sub<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
impl<T, N> Sub<N> for ChunkedArray<T>where
T: PolarsNumericType,
N: Num + ToPrimitive,
type Output = ChunkedArray<T>
type Output = ChunkedArray<T>
-
operator.sourceimpl<'a, T> TakeRandom for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
impl<'a, T> TakeRandom for &'a ChunkedArray<ObjectType<T>>where
T: PolarsObject,
type Item = &'a T
sourcefn get(
&self,
index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>
fn get(
&self,
index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>
sourceunsafe fn get_unchecked(
&self,
index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>
unsafe fn get_unchecked(
&self,
index: usize
) -> Option<<&'a ChunkedArray<ObjectType<T>> as TakeRandom>::Item>
sourceimpl<'a, T> TakeRandom for &'a ChunkedArray<T>where
T: PolarsNumericType,
impl<'a, T> TakeRandom for &'a ChunkedArray<T>where
T: PolarsNumericType,
type Item = <T as PolarsNumericType>::Native
sourcefn get(&self, index: usize) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>
fn get(&self, index: usize) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>
sourceunsafe fn get_unchecked(
&self,
index: usize
) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>
unsafe fn get_unchecked(
&self,
index: usize
) -> Option<<&'a ChunkedArray<T> as TakeRandom>::Item>
sourceimpl<'a> TakeRandom for &'a ChunkedArray<Utf8Type>
impl<'a> TakeRandom for &'a ChunkedArray<Utf8Type>
sourceimpl TakeRandom for ChunkedArray<BooleanType>
impl TakeRandom for ChunkedArray<BooleanType>
type Item = bool
sourcefn get(
&self,
index: usize
) -> Option<<ChunkedArray<BooleanType> as TakeRandom>::Item>
fn get(
&self,
index: usize
) -> Option<<ChunkedArray<BooleanType> as TakeRandom>::Item>
sourceimpl TakeRandom for ChunkedArray<ListType>
impl TakeRandom for ChunkedArray<ListType>
type Item = Series
sourcefn get(
&self,
index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>
fn get(
&self,
index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>
sourceunsafe fn get_unchecked(
&self,
index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>
unsafe fn get_unchecked(
&self,
index: usize
) -> Option<<ChunkedArray<ListType> as TakeRandom>::Item>
sourceimpl<T> TakeRandom for ChunkedArray<T>where
T: PolarsNumericType,
impl<T> TakeRandom for ChunkedArray<T>where
T: PolarsNumericType,
type Item = <T as PolarsNumericType>::Native
sourcefn get(&self, index: usize) -> Option<<ChunkedArray<T> as TakeRandom>::Item>
fn get(&self, index: usize) -> Option<<ChunkedArray<T> as TakeRandom>::Item>
sourceunsafe fn get_unchecked(
&self,
index: usize
) -> Option<<ChunkedArray<T> as TakeRandom>::Item>
unsafe fn get_unchecked(
&self,
index: usize
) -> Option<<ChunkedArray<T> as TakeRandom>::Item>
sourceimpl<'a> TakeRandomUtf8 for &'a ChunkedArray<Utf8Type>
impl<'a> TakeRandomUtf8 for &'a ChunkedArray<Utf8Type>
type Item = &'a str
sourcefn get(
self,
index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>
fn get(
self,
index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>
sourceunsafe fn get_unchecked(
self,
index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>
unsafe fn get_unchecked(
self,
index: usize
) -> Option<<&'a ChunkedArray<Utf8Type> as TakeRandomUtf8>::Item>
sourceimpl<T> ToDummies<T> for ChunkedArray<T>where
T: PolarsIntegerType + Sync,
<T as PolarsNumericType>::Native: NumericNative,
impl<T> ToDummies<T> for ChunkedArray<T>where
T: PolarsIntegerType + Sync,
<T as PolarsNumericType>::Native: NumericNative,
fn to_dummies(&self) -> Result<DataFrame, PolarsError>
sourceimpl Utf8Methods for ChunkedArray<Utf8Type>
impl Utf8Methods for ChunkedArray<Utf8Type>
sourcefn as_time(
&self,
fmt: Option<&str>
) -> Result<Logical<TimeType, Int64Type>, PolarsError>
fn as_time(
&self,
fmt: Option<&str>
) -> Result<Logical<TimeType, Int64Type>, PolarsError>
Parsing string values and return a TimeChunked
sourcefn as_date_not_exact(
&self,
fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>
fn as_date_not_exact(
&self,
fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>
Parsing string values and return a DateChunked
Different from as_date
this function allows matches that not contain the whole string
e.g. “foo-2021-01-01-bar” could match “2021-01-01”
sourcefn as_datetime_not_exact(
&self,
fmt: Option<&str>,
tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>
fn as_datetime_not_exact(
&self,
fmt: Option<&str>,
tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>
Parsing string values and return a DatetimeChunked
Different from as_datetime
this function allows matches that not contain the whole string
e.g. “foo-2021-01-01-bar” could match “2021-01-01”
sourcefn as_date(
&self,
fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>
fn as_date(
&self,
fmt: Option<&str>
) -> Result<Logical<DateType, Int32Type>, PolarsError>
Parsing string values and return a DateChunked
sourcefn as_datetime(
&self,
fmt: Option<&str>,
tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>
fn as_datetime(
&self,
fmt: Option<&str>,
tu: TimeUnit
) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>
Parsing string values and return a DatetimeChunked
sourceimpl Utf8NameSpaceImpl for ChunkedArray<Utf8Type>
impl Utf8NameSpaceImpl for ChunkedArray<Utf8Type>
sourcefn str_lengths(&self) -> ChunkedArray<UInt32Type>
fn str_lengths(&self) -> ChunkedArray<UInt32Type>
sourcefn contains(&self, pat: &str) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn contains(&self, pat: &str) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn contains_literal(
&self,
lit: &str
) -> Result<ChunkedArray<BooleanType>, PolarsError>
fn contains_literal(
&self,
lit: &str
) -> Result<ChunkedArray<BooleanType>, PolarsError>
sourcefn ends_with(&self, sub: &str) -> ChunkedArray<BooleanType>
fn ends_with(&self, sub: &str) -> ChunkedArray<BooleanType>
sourcefn starts_with(&self, sub: &str) -> ChunkedArray<BooleanType>
fn starts_with(&self, sub: &str) -> ChunkedArray<BooleanType>
sourcefn replace(
&'a self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn replace(
&'a self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn replace_literal(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn replace_literal(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn replace_all(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn replace_all(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn replace_literal_all(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn replace_literal_all(
&self,
pat: &str,
val: &str
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn extract(
&self,
pat: &str,
group_index: usize
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn extract(
&self,
pat: &str,
group_index: usize
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
sourcefn extract_all(&self, pat: &str) -> Result<ChunkedArray<ListType>, PolarsError>
fn extract_all(&self, pat: &str) -> Result<ChunkedArray<ListType>, PolarsError>
sourcefn count_match(&self, pat: &str) -> Result<ChunkedArray<UInt32Type>, PolarsError>
fn count_match(&self, pat: &str) -> Result<ChunkedArray<UInt32Type>, PolarsError>
sourcefn to_lowercase(&self) -> ChunkedArray<Utf8Type>
fn to_lowercase(&self) -> ChunkedArray<Utf8Type>
sourcefn to_uppercase(&self) -> ChunkedArray<Utf8Type>
fn to_uppercase(&self) -> ChunkedArray<Utf8Type>
sourcefn concat(&self, other: &ChunkedArray<Utf8Type>) -> ChunkedArray<Utf8Type>
fn concat(&self, other: &ChunkedArray<Utf8Type>) -> ChunkedArray<Utf8Type>
sourcefn str_slice(
&self,
start: i64,
length: Option<u64>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
fn str_slice(
&self,
start: i64,
length: Option<u64>
) -> Result<ChunkedArray<Utf8Type>, PolarsError>
start
and with optional length length
of each of the elements in array
.
start
can be negative, in which case the start counts from the end of the string. Read more