Type Definition polars_core::datatypes::BooleanChunked

pub type BooleanChunked = ChunkedArray<BooleanType>;

Implementations

impl BooleanChunked

pub fn arg_true(&self) -> IdxCa

impl BooleanChunked

pub fn all(&self) -> bool

Check if all values are true

pub fn any(&self) -> bool

Check if any value is true

impl BooleanChunked

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

Available on crate feature random only.

Create ChunkedArray with samples from a Bernoulli distribution.

Trait Implementations

impl AggList for BooleanChunked

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

impl ArgAgg for BooleanChunked

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

Get the index of the minimal value

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

Get the index of the maximal value

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAnd<ChunkedArray<BooleanType>> for BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

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

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOr<ChunkedArray<BooleanType>> for BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitXor<&'_ ChunkedArray<BooleanType>> for &BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl BitXor<ChunkedArray<BooleanType>> for BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl ChunkAgg<u32> for BooleanChunked

Booleans are casted to 1 or 0.

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

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

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

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

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

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

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

impl ChunkAggSeries for BooleanChunked

fn sum_as_series(&self) -> Series

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

fn max_as_series(&self) -> Series

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

fn min_as_series(&self) -> Series

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

fn prod_as_series(&self) -> Series

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

impl ChunkAnyValue for BooleanChunked

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

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

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

Get a single value. Beware this is slow.

impl<'a> ChunkApply<'a, bool, bool> for BooleanChunked

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

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

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

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

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

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

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

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

Apply a closure elementwise including null values.

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

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

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

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

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

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

impl ChunkApplyKernel<BooleanArray> for BooleanChunked

fn apply_kernel(&self, f: &dyn Fn(&BooleanArray) -> ArrayRef) -> Self

Apply kernel and return result as a new ChunkedArray.

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

Apply a kernel that outputs an array of different type.

impl ChunkCast for BooleanChunked

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

Cast a [ChunkedArray] to [DataType]

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

type Item = ChunkedArray<BooleanType>

fn eq_missing(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality and regard missing values as equal.

fn equal(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality.

fn not_equal(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for inequality.

fn gt(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than comparison.

fn gt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Greater than or equal comparison.

fn lt(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than comparison.

fn lt_eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Less than or equal comparison

impl ChunkExpandAtIndex<BooleanType> for BooleanChunked

fn expand_at_index(&self, index: usize, length: usize) -> BooleanChunked

Create a new ChunkedArray filled with values at that index.

impl ChunkFillNull for BooleanChunked

fn fill_null(&self, strategy: FillNullStrategy) -> Result<Self>

Replace None values with one of the following strategies:

impl ChunkFillNullValue<bool> for BooleanChunked

fn fill_null_with_values(&self, value: bool) -> Result<Self>

Replace None values with a give value T.

impl ChunkFilter<BooleanType> for BooleanChunked

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

Filter values in the ChunkedArray with a boolean mask.

impl ChunkFull<bool> for BooleanChunked

fn full(name: &str, value: bool, length: usize) -> Self

Create a ChunkedArray with a single value.

impl ChunkFullNull for BooleanChunked

fn full_null(name: &str, length: usize) -> Self

impl ChunkOps for BooleanChunked

fn rechunk(&self) -> Self

Aggregate to contiguous memory.

fn slice(&self, offset: i64, length: usize) -> Self

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

fn limit(&self, num_elements: usize) -> Self where
    Self: Sized, 

Take a view of top n elements

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

Get the head of the ChunkedArray

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

Get the tail of the ChunkedArray

impl ChunkQuantile<bool> for BooleanChunked

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

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

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

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

impl ChunkReverse<BooleanType> for BooleanChunked

fn reverse(&self) -> Self

Return a reversed version of this array.

impl<'a> ChunkSet<'a, bool, bool> for BooleanChunked

fn set_at_idx<I: IntoIterator<Item = usize>>(
    &'a self,
    idx: I,
    value: Option<bool>
) -> Result<Self>

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

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

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

fn set(&'a self, mask: &BooleanChunked, value: Option<bool>) -> Result<Self>

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

fn set_with<F>(&'a self, mask: &BooleanChunked, f: F) -> Result<Self> where
    F: Fn(Option<bool>) -> Option<bool>, 

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

impl ChunkShift<BooleanType> for BooleanChunked

fn shift(&self, periods: i64) -> Self

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

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

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

impl ChunkSort<BooleanType> for BooleanChunked

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

fn sort(&self, reverse: bool) -> BooleanChunked

Returned a sorted ChunkedArray.

fn argsort(&self, options: SortOptions) -> IdxCa

Retrieve the indexes needed to sort this array.

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

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

impl ChunkTake for BooleanChunked

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

Take values from ChunkedArray by index.

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

Take values from ChunkedArray by index. Note that the iterator will be cloned, so prefer an iterator that takes the owned memory by reference.

impl ChunkTakeEvery<BooleanType> for BooleanChunked

fn take_every(&self, n: usize) -> BooleanChunked

Traverse and collect every nth element in a new array.

impl ChunkUnique<BooleanType> for BooleanChunked

fn unique(&self) -> Result<Self>

Get unique values of a ChunkedArray

fn arg_unique(&self) -> Result<IdxCa>

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

fn is_unique(&self) -> Result<BooleanChunked>

Get a mask of all the unique values.

fn is_duplicated(&self) -> Result<BooleanChunked>

Get a mask of all the duplicated values.

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

Number of unique values in the ChunkedArray

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

Available on crate feature mode only.

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

impl ChunkVar<bool> for BooleanChunked

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkZip<BooleanType> for BooleanChunked

fn zip_with(
    &self,
    mask: &BooleanChunked,
    other: &BooleanChunked
) -> Result<BooleanChunked>

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

impl From<(&'_ str, BooleanArray)> for BooleanChunked

fn from(tpl: (&str, BooleanArray)) -> Self

Converts to this type from the input type.

impl From<BooleanArray> for BooleanChunked

fn from(arr: BooleanArray) -> Self

Converts to this type from the input type.

impl FromIterator<bool> for BooleanChunked

fn from_iter<I: IntoIterator<Item = bool>>(iter: I) -> Self

Creates a value from an iterator.

impl FromParallelIterator<bool> for BooleanChunked

fn from_par_iter<I: IntoParallelIterator<Item = bool>>(iter: I) -> Self

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

impl FromTrustedLenIterator<bool> for BooleanChunked

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

impl IntoGroupsProxy for BooleanChunked

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

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

impl<'a> IntoIterator for &'a BooleanChunked

type Item = Option<bool>

The type of the elements being iterated over.

type IntoIter = Box<dyn PolarsIterator<Item = <&'a ChunkedArray<BooleanType> as IntoIterator>::Item> + 'a, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl IntoSeries for BooleanChunked

fn into_series(self) -> Series

fn is_series() -> bool

impl<'a> IntoTakeRandom<'a> for &'a BooleanChunked

type Item = bool

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

fn take_rand(&self) -> Self::TakeRandom

Create a type that implements TakeRandom.

impl IsIn for BooleanChunked

fn is_in(&self, other: &Series) -> Result<BooleanChunked>

Available on crate feature is_in only.

Check if elements of this array are in the right Series, or List values of the right Series.

impl NewChunkedArray<BooleanType, bool> for BooleanChunked

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]) -> Self

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

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

Create a new ChunkedArray from an iterator.

impl Not for &BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for BooleanChunked

type Output = ChunkedArray<BooleanType>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl QuantileAggSeries for BooleanChunked

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

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

fn median_as_series(&self) -> Series

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

impl RepeatBy for BooleanChunked

fn repeat_by(&self, by: &IdxCa) -> ListChunked

Available on crate feature repeat_by only.

Repeat the values n times, where n is determined by the values in by.

impl TakeRandom for BooleanChunked

type Item = bool

fn get(&self, index: usize) -> Option<Self::Item>

Get a nullable value by index.

unsafe fn get_unchecked(&self, index: usize) -> Option<Self::Item> where
    Self: Sized, 

Get a value by index and ignore the null bit.

impl VarAggSeries for BooleanChunked

fn var_as_series(&self) -> Series

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

fn std_as_series(&self) -> Series

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

impl VecHash for BooleanChunked

fn vec_hash(&self, random_state: RandomState) -> Vec<u64>

Compute the hash for all values in the array.

fn vec_hash_combine(&self, random_state: RandomState, hashes: &mut [u64])

impl ZipOuterJoinColumn for BooleanChunked

fn zip_outer_join_column(
    &self,
    right_column: &Series,
    opt_join_tuples: &[(Option<IdxSize>, Option<IdxSize>)]
) -> Series