Type Definition polars::datatypes::BooleanChunked

type BooleanChunked = ChunkedArray<BooleanType>;

Implementations

impl BooleanChunked

pub fn arg_true(&self) -> UInt32Chunked

impl BooleanChunked

pub fn all_true(&self) -> bool

impl BooleanChunked

pub fn all_false(&self) -> bool

impl BooleanChunked

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

This is supported on crate feature random only.

Create ChunkedArray with samples from a Bernoulli distribution.

Trait Implementations

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

type Output = BooleanChunked

The resulting type after applying the & operator.

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

Performs the & operation.

impl BitAnd<ChunkedArray<BooleanType>> for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the & operator.

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

Performs the & operation.

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

type Output = BooleanChunked

The resulting type after applying the | operator.

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

Performs the | operation.

impl BitOr<ChunkedArray<BooleanType>> for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the | operator.

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

Performs the | operation.

impl ChunkAgg<u32> for BooleanChunked

Booleans are casted to 1 or 0.

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

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

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

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

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

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

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

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

pub fn quantile(&self, quantile: f64) -> Result<Option<u32>>

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

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

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

Apply a closure F elementwise.

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

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

impl ChunkCast for BooleanChunked

pub fn cast<N>(&self) -> Result<ChunkedArray<N>> where
    N: PolarsDataType, 

Cast ChunkedArray<T> to ChunkedArray<N>

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

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

Check for equality and regard missing values as equal.

pub fn eq(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for equality.

pub fn neq(&self, rhs: &BooleanChunked) -> BooleanChunked

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl ChunkFillNone for BooleanChunked

pub fn fill_none(&self, strategy: FillNoneStrategy) -> Result<Self>

Replace None values with one of the following strategies:

impl ChunkFillNoneValue<bool> for BooleanChunked

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

Replace None values with a give value T.

impl ChunkFilter<BooleanType> for BooleanChunked

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

Filter values in the ChunkedArray with a boolean mask.

impl ChunkOps for BooleanChunked

pub fn rechunk(&self, chunk_lengths: Option<&[usize]>) -> Result<Self>

Aggregate to chunk id. A chunk id is a vector of the chunk lengths.

pub fn optional_rechunk<A>(&self, rhs: &ChunkedArray<A>) -> Result<Option<Self>>

Only rechunk if lhs and rhs don't match

impl ChunkReverse<BooleanType> for BooleanChunked

pub fn reverse(&self) -> Self

Return a reversed version of this array.

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

pub fn set_at_idx<I: AsTakeIndex>(
    &'a self,
    idx: &I,
    value: Option<bool>
) -> Result<Self>

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

pub fn set_at_idx_with<I: AsTakeIndex, 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.

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

pub 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

pub fn shift(&self, periods: i32) -> Result<Self>

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

pub fn shift_and_fill(
    &self,
    periods: i32,
    fill_value: Option<bool>
) -> Result<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

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

Returned a sorted ChunkedArray.

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

Sort this array in place.

pub fn argsort(&self, reverse: bool) -> Vec<usize>

Retrieve the indexes needed to sort this array.

impl ChunkTake for BooleanChunked

pub fn take(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self where
    Self: Sized, 

Take values from ChunkedArray by index.

pub unsafe fn take_unchecked(
    &self,
    indices: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by index

pub fn take_opt(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by Option.

pub unsafe fn take_opt_unchecked(
    &self,
    indices: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Self

Take values from ChunkedArray by Option.

pub fn take_from_single_chunked(&self, idx: &UInt32Chunked) -> Result<Self>

pub fn take_from_single_chunked_iter(
    &self,
    indices: impl Iterator<Item = usize>
) -> Result<Self> where
    Self: Sized, 

impl ChunkUnique<BooleanType> for BooleanChunked

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

Get unique values of a ChunkedArray

pub fn arg_unique(&self) -> Result<Vec<usize>>

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

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

Get a mask of all the unique values.

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

Get a mask of all the duplicated values.

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

Number of unique values in the ChunkedArray

pub fn value_counts(&self) -> Result<DataFrame>

Count the unique values.

impl ChunkVar<bool> for BooleanChunked

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

Compute the variance of this ChunkedArray/Series.

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

Compute the standard deviation of this ChunkedArray/Series.

impl ChunkWindow for BooleanChunked

pub fn rolling_sum(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling sum (moving sum) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their sum.

pub fn rolling_mean(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling mean (moving mean) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their mean.

pub fn rolling_min(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling min (moving min) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their min.

pub fn rolling_max(
    &self,
    _window_size: usize,
    _weight: Option<&[f64]>,
    _ignore_null: bool
) -> Result<Self> where
    Self: Sized, 

Apply a rolling max (moving max) over the values in this array. A window of length window_size will traverse the array. The values that fill this window will (optionally) be multiplied with the weights given by the weight vector. The resulting values will be aggregated to their max.

impl ChunkZip<BooleanType> for BooleanChunked

pub 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

pub fn zip_with_series(
    &self,
    mask: &BooleanChunked,
    other: &Series
) -> Result<ChunkedArray<BooleanType>>

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

impl FromIterator<bool> for BooleanChunked

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

Creates a value from an iterator.

impl FromParallelIterator<bool> for BooleanChunked

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

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

impl IntoGroupTuples for BooleanChunked

pub fn group_tuples(&self) -> Vec<(usize, Vec<usize>)>

Create the tuples need for a groupby operation. * The first value in te 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 = Self::Item> + 'a>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> Self::IntoIter

Decides which iterator fits best the current chunked array. The decision are based on the number of chunks and the existence of null values.

impl<'a> IntoNoNullIterator for &'a BooleanChunked

type Item = bool

type IntoIter = Box<dyn PolarsIterator<Item = Self::Item> + 'a>

pub fn into_no_null_iter(self) -> Self::IntoIter

Decides which iterator fits best the current no null chunked array. The decision are based on the number of chunks.

impl<'a> IntoParallelIterator for &'a BooleanChunked

This is supported on crate feature parallel only.

Convert $ca_iter into a ParallelIterator using the most efficient ParallelIterator implementation for the given $ca_type.

• If $ca_type has only a chunk and has no null values, it uses $single_chunk_return_option.
• If $ca_type has only a chunk and does have null values, it uses $single_chunk_null_check_return_option.
• If $ca_type has many chunks and has no null values, it uses $many_chunk_return_option.
• If $ca_type has many chunks and does have null values, it uses $many_chunk_null_check_return_option.

type Iter = BooleanParIterDispatcher<'a>

The parallel iterator type that will be created.

type Item = Option<bool>

The type of item that the parallel iterator will produce.

pub fn into_par_iter(self) -> Self::Iter

Converts self into a parallel iterator.

impl IntoSeries for BooleanChunked

pub fn into_series(self) -> Series

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

type Item = bool

type TakeRandom = Box<dyn TakeRandom<Item = Self::Item> + 'a>

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

Create a type that implements TakeRandom.

impl Not for &BooleanChunked

type Output = BooleanChunked

The resulting type after applying the ! operator.

pub fn not(self) -> Self::Output

Performs the unary ! operation.

impl Not for BooleanChunked

type Output = BooleanChunked

The resulting type after applying the ! operator.

pub fn not(self) -> Self::Output

Performs the unary ! operation.

impl NumOpsDispatch for BooleanChunked

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

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

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

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

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

impl ToDummies<BooleanType> for BooleanChunked

pub fn to_dummies(&self) -> Result<DataFrame>

impl ZipOuterJoinColumn for BooleanChunked

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