Enum polars::series::Series

pub enum Series {
    UInt32(ChunkedArray<UInt32Type>),
    Int32(ChunkedArray<Int32Type>),
    Int64(ChunkedArray<Int64Type>),
    Float32(ChunkedArray<Float32Type>),
    Float64(ChunkedArray<Float64Type>),
    Utf8(ChunkedArray<Utf8Type>),
    Bool(ChunkedArray<BooleanType>),
    Date32(ChunkedArray<Date32Type>),
    Date64(ChunkedArray<Date64Type>),
    Time64Ns(ChunkedArray<Time64NanosecondType>),
    DurationNs(ChunkedArray<DurationNanosecondType>),
}

Variants

UInt32(ChunkedArray<UInt32Type>)

Int32(ChunkedArray<Int32Type>)

Int64(ChunkedArray<Int64Type>)

Float32(ChunkedArray<Float32Type>)

Float64(ChunkedArray<Float64Type>)

Utf8(ChunkedArray<Utf8Type>)

Bool(ChunkedArray<BooleanType>)

Date32(ChunkedArray<Date32Type>)

Date64(ChunkedArray<Date64Type>)

Time64Ns(ChunkedArray<Time64NanosecondType>)

DurationNs(ChunkedArray<DurationNanosecondType>)

Implementations

impl Series

pub fn sum<T>(&self) -> Option<T> where
    T: NumCast + Zero + ToPrimitive, 

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

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.sum(), Some(6));

pub fn min<T>(&self) -> Option<T> where
    T: NumCast + Zero + ToPrimitive, 

Returns the minimum value in the array, according to the natural order. Returns an option because the array is nullable.

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.min(), Some(1));

pub fn max<T>(&self) -> Option<T> where
    T: NumCast + Zero + ToPrimitive, 

Returns the maximum value in the array, according to the natural order. Returns an option because the array is nullable.

let s = Series::new("days", [1, 2, 3].as_ref());
assert_eq!(s.max(), Some(3));

pub fn mean<T>(&self) -> Option<T> where
    T: NumCast + Zero + ToPrimitive + Div<Output = T>, 

impl Series

pub fn chunk_lengths(&self) -> &Vec<usize>

Get the lengths of the underlying chunks

pub fn name(&self) -> &str

Name of series.

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

Rename series.

pub fn field(&self) -> &Field

Get field (used in schema)

pub fn dtype(&self) -> &ArrowDataType

Get datatype of series.

pub fn chunks(&self) -> &Vec<ArrayRef>

Underlying chunks.

pub fn n_chunks(&self) -> usize

No. of chunks

pub fn i32(&self) -> Result<&Int32Chunked>

Unpack to ChunkedArray

let s: Series = [1, 2, 3].iter().collect();
let s_squared: Series = s.i32()
    .unwrap()
    .into_iter()
    .map(|opt_v| {
        match opt_v {
            Some(v) => Some(v * v),
            None => None, // null value
        }
}).collect();

pub fn i64(&self) -> Result<&Int64Chunked>

Unpack to ChunkedArray

pub fn f32(&self) -> Result<&Float32Chunked>

Unpack to ChunkedArray

pub fn f64(&self) -> Result<&Float64Chunked>

Unpack to ChunkedArray

pub fn u32(&self) -> Result<&UInt32Chunked>

Unpack to ChunkedArray

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

Unpack to ChunkedArray

pub fn utf8(&self) -> Result<&Utf8Chunked>

Unpack to ChunkedArray

pub fn date32(&self) -> Result<&Date32Chunked>

Unpack to ChunkedArray

pub fn date64(&self) -> Result<&Date64Chunked>

Unpack to ChunkedArray

pub fn time64ns(&self) -> Result<&Time64NsChunked>

Unpack to ChunkedArray

pub fn duration_ns(&self) -> Result<&DurationNsChunked>

Unpack to ChunkedArray

pub fn append_array(&mut self, other: ArrayRef) -> Result<()>

pub fn limit(&self, num_elements: usize) -> Result<Self>

Take num_elements from the top as a zero copy view.

pub fn slice(&self, offset: usize, length: usize) -> Result<Self>

Get a zero copy view of the data.

pub fn append(&mut self, other: &Self) -> Result<()>

Append a Series of the same type in place.

pub fn filter<T: AsRef<BooleanChunked>>(&self, filter: T) -> Result<Self>

Filter by boolean mask. This operation clones data.

pub fn take_iter(
    &self,
    iter: impl Iterator<Item = usize>,
    capacity: Option<usize>
) -> Result<Self>

Take by index from an iterator. This operation clones the data.

pub fn take_opt_iter(
    &self,
    iter: impl Iterator<Item = Option<usize>>,
    capacity: Option<usize>
) -> Result<Self>

Take by index from an iterator. This operation clones the data.

pub fn take<T: TakeIndex>(&self, indices: &T) -> Result<Self>

Take by index. This operation is clone.

pub fn len(&self) -> usize

Get length of series.

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

Aggregate all chunks to a contiguous array of memory.

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

Get the head of the Series.

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

Get the tail of the Series.

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

Cast to an some primitive type.

pub fn get(&self, index: usize) -> AnyType

Get a single value by index. Don't use this operation for loops as a runtime cast is needed for every iteration.

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

Sort in place.

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

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

Retrieve the indexes needed for a sort.

pub fn null_count(&self) -> usize

Count the null values.

pub fn unique(&self) -> Self

Get unique values in the Series.

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

Get first indexes of unique values.

pub fn is_null(&self) -> BooleanChunked

Get a mask of the null values.

pub fn null_bits(&self) -> Vec<(usize, Option<Buffer>)>

Get the bits that represent the null values of the underlying ChunkedArray

pub fn reverse(&self) -> Self

return a Series in reversed order

impl Series

pub fn series_equal(&self, other: &Series) -> bool

Trait Implementations

impl<'_> Add<&'_ Series> for &'_ Series

type Output = Series

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Series> for Series

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, '_> Add<T> for &'_ Series where
    T: Num + NumCast, 

type Output = Series

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T> Add<T> for Series where
    T: Num + NumCast, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl AsMut<ChunkedArray<BooleanType>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<BooleanType>

Performs the conversion.

impl AsMut<ChunkedArray<Float32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Float64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Float64Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Int64Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Int64Type>

Performs the conversion.

impl AsMut<ChunkedArray<UInt32Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<UInt32Type>

Performs the conversion.

impl AsMut<ChunkedArray<Utf8Type>> for Series

fn as_mut(&mut self) -> &mut ChunkedArray<Utf8Type>

Performs the conversion.

impl AsRef<ChunkedArray<BooleanType>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Float32Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Float64Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Int32Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Int64Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<UInt32Type>> for Series

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

Performs the conversion.

impl AsRef<ChunkedArray<Utf8Type>> for Series

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

Performs the conversion.

impl Clone for Series

fn clone(&self) -> Series

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'_> CmpOps<&'_ Series> for Series

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

Create a boolean mask by checking for equality.

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

Create a boolean mask by checking for inequality.

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

Create a boolean mask by checking if lhs > rhs.

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

Create a boolean mask by checking if lhs >= rhs.

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

Create a boolean mask by checking if lhs < rhs.

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

Create a boolean mask by checking if lhs <= rhs.

impl<'_> CmpOps<&'_ str> for Series

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl<Rhs> CmpOps<Rhs> for Series where
    Rhs: NumComp, 

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

Check for equality.

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

Check for inequality.

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

Greater than comparison.

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

Greater than or equal comparison.

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

Less than comparison.

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

Less than or equal comparison

impl Debug for Series

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Display for Series

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'_> Div<&'_ Series> for &'_ Series

type Output = Series

The resulting type after applying the / operator.

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

let s: Series = [1, 2, 3].iter().collect();
let out = &s / &s;

impl Div<Series> for Series

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T, '_> Div<T> for &'_ Series where
    T: Num + NumCast, 

type Output = Series

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T> Div<T> for Series where
    T: Num + NumCast, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<'a> FromIterator<&'a bool> for Series

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

Creates a value from an iterator.

impl<'a> FromIterator<&'a f32> for Series

fn from_iter<I: IntoIterator<Item = &'a f32>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a f64> for Series

fn from_iter<I: IntoIterator<Item = &'a f64>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i32> for Series

fn from_iter<I: IntoIterator<Item = &'a i32>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a i64> for Series

fn from_iter<I: IntoIterator<Item = &'a i64>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a str> for Series

fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self

Creates a value from an iterator.

impl<'a> FromIterator<&'a u32> for Series

fn from_iter<I: IntoIterator<Item = &'a u32>>(iter: I) -> Self

Creates a value from an iterator.

impl FromIterator<Option<bool>> for Series

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

Creates a value from an iterator.

impl FromIterator<Option<f32>> for Series

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

Creates a value from an iterator.

impl FromIterator<Option<f64>> for Series

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

Creates a value from an iterator.

impl FromIterator<Option<i32>> for Series

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

Creates a value from an iterator.

impl FromIterator<Option<i64>> for Series

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

Creates a value from an iterator.

impl FromIterator<Option<u32>> for Series

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

Creates a value from an iterator.

impl FromIterator<bool> for Series

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

Creates a value from an iterator.

impl FromIterator<f32> for Series

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

Creates a value from an iterator.

impl FromIterator<f64> for Series

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

Creates a value from an iterator.

impl FromIterator<i32> for Series

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

Creates a value from an iterator.

impl FromIterator<i64> for Series

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

Creates a value from an iterator.

impl FromIterator<u32> for Series

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

Creates a value from an iterator.

impl<T, '_> LhsNumOps<&'_ Series> for T where
    T: Num + NumCast, 

type Output = Series

fn add(self, rhs: &Series) -> Self::Output

fn sub(self, rhs: &Series) -> Self::Output

fn div(self, rhs: &Series) -> Self::Output

fn mul(self, rhs: &Series) -> Self::Output

impl<'_> Mul<&'_ Series> for &'_ Series

type Output = Series

The resulting type after applying the * operator.

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

let s: Series = [1, 2, 3].iter().collect();
let out = &s * &s;

impl Mul<Series> for Series

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T, '_> Mul<T> for &'_ Series where
    T: Num + NumCast, 

type Output = Series

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for Series where
    T: Num + NumCast, 

type Output = Self

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<'a, T: AsRef<[&'a str]>> NamedFrom<T, [&'a str]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'a, T: AsRef<[Option<&'a str>]>> NamedFrom<T, [Option<&'a str>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<String>]>> NamedFrom<T, [Option<String>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<bool>]>> NamedFrom<T, [Option<bool>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f32>]>> NamedFrom<T, [Option<f32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<f64>]>> NamedFrom<T, [Option<f64>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i32>]>> NamedFrom<T, [Option<i32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<i64>]>> NamedFrom<T, [Option<i64>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[Option<u32>]>> NamedFrom<T, [Option<u32>]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[String]>> NamedFrom<T, [String]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[bool]>> NamedFrom<T, [bool]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f32]>> NamedFrom<T, [f32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[f64]>> NamedFrom<T, [f64]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i32]>> NamedFrom<T, [i32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[i64]>> NamedFrom<T, [i64]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<T: AsRef<[u32]>> NamedFrom<T, [u32]> for Series

fn new(name: &str, v: T) -> Self

Initialize by name and values.

impl<'_> Sub<&'_ Series> for &'_ Series

type Output = Series

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Series> for Series

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, '_> Sub<T> for &'_ Series where
    T: Num + NumCast, 

type Output = Series

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.

impl<T> Sub<T> for Series where
    T: Num + NumCast, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, rhs: T) -> Self::Output

Performs the - operation.