Struct Logical

pub struct Logical<Logical, Physical>
where
    Logical: PolarsDataType,
    Physical: PolarsDataType,
{
    pub phys: ChunkedArray<Physical>,
    pub dtype: DataType,
    /* private fields */
}

Maps a logical type to a chunked array implementation of the physical type. This saves a lot of compiler bloat and allows us to reuse functionality.

Fields

phys: ChunkedArray<Physical>

dtype: DataType

Implementations

impl<T> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

pub fn sort_with( &self, options: SortOptions, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

pub fn sort( &self, descending: bool, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Returned a sorted ChunkedArray.

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

Retrieve the indexes needed to sort this array.

impl Logical<DecimalType, Int128Type>

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

pub fn scale(&self) -> usize

pub fn to_scale( &self, scale: usize, ) -> Result<Cow<'_, Logical<DecimalType, Int128Type>>, PolarsError>

impl<T> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

pub fn is_enum(&self) -> bool

pub fn uses_lexical_ordering(&self) -> bool

Return whether or not the CategoricalChunked uses the lexical order of the string values when sorting.

pub fn full_null_with_dtype( name: PlSmallStr, length: usize, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

pub fn from_cats_and_dtype( cat_ids: ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Create a CategoricalChunked from a physical array and dtype.

Checks that all the category ids are valid, mapping invalid ones to nulls.

pub unsafe fn from_cats_and_dtype_unchecked( cat_ids: ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, dtype: DataType, ) -> Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

Create a CategoricalChunked from a physical array and dtype.

Safety

It’s not checked that the indices are in-bounds or that the dtype is correct.

pub fn get_mapping(&self) -> &Arc<CategoricalMapping>

Get a reference to the mapping of categorical types to the string values.

pub fn iter_str(&self) -> impl PolarsIterator

Create an Iterator that iterates over the &str values of the CategoricalChunked.

pub fn from_str_iter<'a, I>( name: PlSmallStr, dtype: DataType, strings: I, ) -> Result<Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, PolarsError>

where I: IntoIterator<Item = Option<&'a str>>,

Converts from strings to this CategoricalChunked.

If this dtype is an Enum any non-existing strings get mapped to null.

pub fn to_arrow( &self, compat_level: CompatLevel, ) -> DictionaryArray<<T as PolarsCategoricalType>::Native>

impl<K, T> Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

pub unsafe fn new_logical( phys: ChunkedArray<T>, dtype: DataType, ) -> Logical<K, T>

Safety

You must uphold the logical types’ invariants.

impl<K, T> Logical<K, T>

where K: PolarsDataType, T: PolarsDataType, Logical<K, T>: LogicalType,

pub fn name(&self) -> &PlSmallStr

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

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn null_count(&self) -> usize

pub fn has_nulls(&self) -> bool

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

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

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

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

pub fn field(&self) -> Field

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

pub fn physical_mut(&mut self) -> &mut ChunkedArray<T>

pub fn into_physical(self) -> ChunkedArray<T>

impl Logical<DateType, Int32Type>

pub fn as_date_iter(&self) -> impl TrustedLen

pub fn from_naive_date<I>( name: PlSmallStr, v: I, ) -> Logical<DateType, Int32Type>

where I: IntoIterator<Item = NaiveDate>,

Construct a new DateChunked from an iterator over NaiveDate.

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Date into String with the given format. See chrono strftime/strptime.

pub fn strftime( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Date into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn from_naive_date_options<I>( name: PlSmallStr, v: I, ) -> Logical<DateType, Int32Type>

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

Construct a new DateChunked from an iterator over optional NaiveDate.

impl Logical<DatetimeType, Int64Type>

pub fn as_datetime_iter(&self) -> impl TrustedLen

pub fn time_unit(&self) -> TimeUnit

pub fn time_zone(&self) -> &Option<TimeZone>

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Datetime into String with the given format. See chrono strftime/strptime.

pub fn strftime( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Datetime into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn from_naive_datetime<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

where I: IntoIterator<Item = NaiveDateTime>,

Construct a new DatetimeChunked from an iterator over NaiveDateTime.

pub fn from_naive_datetime_options<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

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

pub fn cast_time_unit(&self, tu: TimeUnit) -> Logical<DatetimeType, Int64Type>

Change the underlying TimeUnit. And update the data accordingly.

pub fn set_time_unit(&mut self, time_unit: TimeUnit)

Change the underlying TimeUnit. This does not modify the data.

pub fn set_time_zone(&mut self, time_zone: TimeZone) -> Result<(), PolarsError>

Change the underlying TimeZone. This does not modify the data. This does not validate the time zone - it’s up to the caller to verify that it’s already been validated.

pub fn set_time_unit_and_time_zone( &mut self, time_unit: TimeUnit, time_zone: TimeZone, ) -> Result<(), PolarsError>

Change the underlying TimeUnit and TimeZone. This does not modify the data. This does not validate the time zone - it’s up to the caller to verify that it’s already been validated.

impl Logical<DurationType, Int64Type>

pub fn time_unit(&self) -> TimeUnit

pub fn cast_time_unit(&self, tu: TimeUnit) -> Logical<DurationType, Int64Type>

Change the underlying TimeUnit. And update the data accordingly.

pub fn set_time_unit(&mut self, tu: TimeUnit)

Change the underlying TimeUnit. This does not modify the data.

pub fn to_string( &self, format: &str, ) -> Result<ChunkedArray<StringType>, PolarsError>

Convert from Duration to String; note that strftime format strings are not supported, only the specifiers ‘iso’ and ‘polars’.

pub fn from_duration<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DurationType, Int64Type>

where I: IntoIterator<Item = TimeDelta>,

Construct a new DurationChunked from an iterator over ChronoDuration.

pub fn from_duration_options<I>( name: PlSmallStr, v: I, tu: TimeUnit, ) -> Logical<DurationType, Int64Type>

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

Construct a new DurationChunked from an iterator over optional ChronoDuration.

impl Logical<TimeType, Int64Type>

pub fn to_string(&self, format: &str) -> ChunkedArray<StringType>

Convert from Time into String with the given format. See chrono strftime/strptime.

pub fn strftime(&self, format: &str) -> ChunkedArray<StringType>

Convert from Time into String with the given format. See chrono strftime/strptime.

Alias for to_string.

pub fn as_time_iter(&self) -> impl TrustedLen

pub fn from_naive_time<I>( name: PlSmallStr, v: I, ) -> Logical<TimeType, Int64Type>

where I: IntoIterator<Item = NaiveTime>,

Construct a new TimeChunked from an iterator over NaiveTime.

pub fn from_naive_time_options<I>( name: PlSmallStr, v: I, ) -> Logical<TimeType, Int64Type>

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

Construct a new TimeChunked from an iterator over optional NaiveTime.

Trait Implementations

impl Add for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the + operator.

fn add( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Add>::Output

Performs the + operation.

impl<T> ChunkAggSeries for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: ChunkAgg<<T as PolarsCategoricalType>::Native>,

fn min_reduce(&self) -> Scalar

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

fn max_reduce(&self) -> Scalar

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

fn sum_reduce(&self) -> Scalar

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

fn prod_reduce(&self) -> Scalar

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

impl<T> ChunkCompareEq<&ChunkedArray<StringType>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<<T as PolarsCategoricalType>::Native, Item = ChunkedArray<BooleanType>>,

type Item = ChunkedArray<BooleanType>

fn equal( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for equality.

fn equal_missing( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&ChunkedArray<StringType>>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<&'a ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, Item = ChunkedArray<BooleanType>>,

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

fn equal( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for equality.

fn equal_missing( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareEq<&str> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareEq<<T as PolarsCategoricalType>::Native, Item = ChunkedArray<BooleanType>>,

type Item = ChunkedArray<BooleanType>

fn equal( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for equality.

fn equal_missing( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for equality where None == None.

fn not_equal( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for inequality.

fn not_equal_missing( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareEq<&str>>::Item

Check for inequality where None == None.

impl<T> ChunkCompareIneq<&ChunkedArray<StringType>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

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

fn gt( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &ChunkedArray<StringType>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&ChunkedArray<StringType>>>::Item

Less than or equal comparison

impl<T> ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType, ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>: for<'a> ChunkCompareIneq<&'a ChunkedArray<<T as PolarsCategoricalType>::PolarsPhysical>, Item = ChunkedArray<BooleanType>>,

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

fn gt( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>>>::Item

Less than or equal comparison

impl<T> ChunkCompareIneq<&str> for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

type Item = ChunkedArray<BooleanType>

fn gt( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Greater than comparison.

fn gt_eq( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Greater than or equal comparison.

fn lt( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Less than comparison.

fn lt_eq( &self, rhs: &str, ) -> <Logical<T, <T as PolarsCategoricalType>::PolarsPhysical> as ChunkCompareIneq<&str>>::Item

Less than or equal comparison

impl<K, T> Clone for Logical<K, T>

where K: PolarsDataType, T: PolarsDataType,

fn clone(&self) -> Logical<K, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl DateMethods for Logical<DateType, Int32Type>

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, ) -> Logical<DateType, Int32Type>

fn year(&self) -> ChunkedArray<Int32Type>

Extract month from underlying NaiveDate representation. Returns the year number in the calendar date.

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

Extract year from underlying NaiveDate representation. Returns whether the year is a leap year.

fn iso_year(&self) -> ChunkedArray<Int32Type>

This year number might not match the calendar year number.

fn quarter(&self) -> ChunkedArray<Int8Type>

Extract month from underlying NaiveDateTime representation. Quarters range from 1 to 4.

fn month(&self) -> ChunkedArray<Int8Type>

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

fn week(&self) -> ChunkedArray<Int8Type>

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

fn day(&self) -> ChunkedArray<Int8Type>

Extract day from underlying NaiveDate representation. Returns the day of month starting from 1.

fn ordinal(&self) -> ChunkedArray<Int16Type>

Returns the day of year starting from 1.

fn new_from_parts( year: &ChunkedArray<Int32Type>, month: &ChunkedArray<Int8Type>, day: &ChunkedArray<Int8Type>, name: PlSmallStr, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

Construct a date ChunkedArray from individual time components.

impl DatetimeMethods for Logical<DatetimeType, Int64Type>

fn year(&self) -> ChunkedArray<Int32Type>

Extract month from underlying NaiveDateTime representation. Returns the year number in the calendar date.

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

Extract year from underlying NaiveDate representation. Returns whether the year is a leap year.

fn iso_year(&self) -> ChunkedArray<Int32Type>

fn quarter(&self) -> ChunkedArray<Int8Type>

Extract quarter from underlying NaiveDateTime representation. Quarters range from 1 to 4.

fn month(&self) -> ChunkedArray<Int8Type>

Extract month from underlying NaiveDateTime representation. Returns the month number starting from 1.

fn weekday(&self) -> ChunkedArray<Int8Type>

Extract ISO weekday from underlying NaiveDateTime representation. Returns the weekday number where monday = 1 and sunday = 7

fn week(&self) -> ChunkedArray<Int8Type>

Returns the ISO week number starting from 1. The return value ranges from 1 to 53. (The last week of year differs by years.)

fn day(&self) -> ChunkedArray<Int8Type>

Extract day from underlying NaiveDateTime representation. Returns the day of month starting from 1.

fn hour(&self) -> ChunkedArray<Int8Type>

Extract hour from underlying NaiveDateTime representation. Returns the hour number from 0 to 23.

fn minute(&self) -> ChunkedArray<Int8Type>

Extract minute from underlying NaiveDateTime representation. Returns the minute number from 0 to 59.

fn second(&self) -> ChunkedArray<Int8Type>

Extract second from underlying NaiveDateTime representation. Returns the second number from 0 to 59.

fn nanosecond(&self) -> ChunkedArray<Int32Type>

Extract second from underlying NaiveDateTime representation. Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn ordinal(&self) -> ChunkedArray<Int16Type>

Returns the day of year starting from 1.

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, tu: TimeUnit, ) -> Logical<DatetimeType, Int64Type>

fn new_from_parts( year: &ChunkedArray<Int32Type>, month: &ChunkedArray<Int8Type>, day: &ChunkedArray<Int8Type>, hour: &ChunkedArray<Int8Type>, minute: &ChunkedArray<Int8Type>, second: &ChunkedArray<Int8Type>, nanosecond: &ChunkedArray<Int32Type>, ambiguous: &ChunkedArray<StringType>, time_unit: &TimeUnit, time_zone: Option<TimeZone>, name: PlSmallStr, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

Construct a datetime ChunkedArray from individual time components.

impl Div for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the / operator.

fn div( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Div>::Output

Performs the / operation.

impl DurationMethods for Logical<DurationType, Int64Type>

fn hours(&self) -> ChunkedArray<Int64Type>

Extract the hours from a Duration

fn days(&self) -> ChunkedArray<Int64Type>

Extract the days from a Duration

fn minutes(&self) -> ChunkedArray<Int64Type>

Extract the seconds from a Duration

fn seconds(&self) -> ChunkedArray<Int64Type>

Extract the seconds from a Duration

fn milliseconds(&self) -> ChunkedArray<Int64Type>

Extract the milliseconds from a Duration

fn microseconds(&self) -> ChunkedArray<Int64Type>

Extract the microseconds from a Duration

fn nanoseconds(&self) -> ChunkedArray<Int64Type>

Extract the nanoseconds from a Duration

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

fn from(a: Logical<DateType, Int32Type>) -> Series

Converts to this type from the input type.

impl From<Logical<DatetimeType, Int64Type>> for Series

fn from(a: Logical<DatetimeType, Int64Type>) -> Series

Converts to this type from the input type.

impl From<Logical<DurationType, Int64Type>> for Series

fn from(a: Logical<DurationType, Int64Type>) -> Series

Converts to this type from the input type.

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

fn from(a: Logical<TimeType, Int64Type>) -> Series

Converts to this type from the input type.

impl<T> IntoGroupsType for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

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

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

impl IntoSeries for Logical<DateType, Int32Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DatetimeType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DecimalType, Int128Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<DurationType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl<T> IntoSeries for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

fn into_series(self) -> Series

fn is_series() -> bool

impl IntoSeries for Logical<TimeType, Int64Type>

fn into_series(self) -> Series

fn is_series() -> bool

impl LogicalType for Logical<DateType, Int32Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl LogicalType for Logical<DatetimeType, Int64Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl LogicalType for Logical<DecimalType, Int128Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl LogicalType for Logical<DurationType, Int64Type>

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl<T> LogicalType for Logical<T, <T as PolarsCategoricalType>::PolarsPhysical>

where T: PolarsCategoricalType,

fn dtype(&self) -> &DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl LogicalType for Logical<TimeType, Int64Type>

fn dtype(&self) -> &'static DataType

Get data type of ChunkedArray.

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

Gets AnyValue from LogicalType

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

Safety

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

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

impl Mul for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the * operator.

fn mul( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Mul>::Output

Performs the * operation.

impl<T> NamedFrom<T, [NaiveDate]> for Logical<DateType, Int32Type>

where T: AsRef<[NaiveDate]>,

fn new(name: PlSmallStr, v: T) -> Logical<DateType, Int32Type>

Initialize by name and values.

impl<T> NamedFrom<T, [NaiveDateTime]> for Logical<DatetimeType, Int64Type>

where T: AsRef<[NaiveDateTime]>,

fn new(name: PlSmallStr, v: T) -> Logical<DatetimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [NaiveTime]> for Logical<TimeType, Int64Type>

where T: AsRef<[NaiveTime]>,

fn new(name: PlSmallStr, v: T) -> Logical<TimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveDate>]> for Logical<DateType, Int32Type>

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

fn new(name: PlSmallStr, v: T) -> Logical<DateType, Int32Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveDateTime>]> for Logical<DatetimeType, Int64Type>

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

fn new(name: PlSmallStr, v: T) -> Logical<DatetimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<NaiveTime>]> for Logical<TimeType, Int64Type>

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

fn new(name: PlSmallStr, v: T) -> Logical<TimeType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [Option<TimeDelta>]> for Logical<DurationType, Int64Type>

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

fn new(name: PlSmallStr, v: T) -> Logical<DurationType, Int64Type>

Initialize by name and values.

impl<T> NamedFrom<T, [TimeDelta]> for Logical<DurationType, Int64Type>

where T: AsRef<[TimeDelta]>,

fn new(name: PlSmallStr, v: T) -> Logical<DurationType, Int64Type>

Initialize by name and values.

impl PolarsMonthEnd for Logical<DateType, Int32Type>

fn month_end( &self, _time_zone: Option<&Tz>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsMonthEnd for Logical<DatetimeType, Int64Type>

fn month_end( &self, time_zone: Option<&Tz>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl PolarsMonthStart for Logical<DateType, Int32Type>

fn month_start( &self, _tz: Option<&Tz>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsMonthStart for Logical<DatetimeType, Int64Type>

fn month_start( &self, tz: Option<&Tz>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl PolarsRound for Logical<DateType, Int32Type>

fn round( &self, every: &ChunkedArray<StringType>, _tz: Option<&Tz>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsRound for Logical<DatetimeType, Int64Type>

fn round( &self, every: &ChunkedArray<StringType>, tz: Option<&Tz>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl PolarsTruncate for Logical<DateType, Int32Type>

fn truncate( &self, _tz: Option<&Tz>, every: &ChunkedArray<StringType>, ) -> Result<Logical<DateType, Int32Type>, PolarsError>

impl PolarsTruncate for Logical<DatetimeType, Int64Type>

fn truncate( &self, tz: Option<&Tz>, every: &ChunkedArray<StringType>, ) -> Result<Logical<DatetimeType, Int64Type>, PolarsError>

impl Sub for &Logical<DecimalType, Int128Type>

type Output = Result<Logical<DecimalType, Int128Type>, PolarsError>

The resulting type after applying the - operator.

fn sub( self, rhs: &Logical<DecimalType, Int128Type>, ) -> <&Logical<DecimalType, Int128Type> as Sub>::Output

Performs the - operation.

impl TimeMethods for Logical<TimeType, Int64Type>

fn hour(&self) -> ChunkedArray<Int8Type>

Extract hour from underlying NaiveDateTime representation. Returns the hour number from 0 to 23.

fn minute(&self) -> ChunkedArray<Int8Type>

Extract minute from underlying NaiveDateTime representation. Returns the minute number from 0 to 59.

fn second(&self) -> ChunkedArray<Int8Type>

Extract second from underlying NaiveDateTime representation. Returns the second number from 0 to 59.

fn nanosecond(&self) -> ChunkedArray<Int32Type>

Extract second from underlying NaiveDateTime representation. Returns the number of nanoseconds since the whole non-leap second. The range from 1,000,000,000 to 1,999,999,999 represents the leap second.

fn parse_from_str_slice( name: PlSmallStr, v: &[&str], fmt: &str, ) -> Logical<TimeType, Int64Type>