Struct blackjack::series::Series

pub struct Series<T>where
    T: BlackJackData,{
    pub name: Option<String>,
    pub values: Vec<T>,
    /* private fields */
}

Series struct for containing underlying Array and other meta data.

Fields

name: Option<String>

Name of the series, if added to a dataframe without a name, it will be assigned a default name equalling the cound of columns in the dataframe.

values: Vec<T>

The underlying values of the Series

Implementations

impl<T> Series<T>where
    T: BlackJackData,

Constructor methods for Series<T>

pub fn arange(start: T, stop: T) -> Selfwhere
    T: Integer + BlackJackData + ToPrimitive,
    Range<T>: Iterator,
    Vec<T>: FromIterator<<Range<T> as Iterator>::Item>,

Create a new Series struct from an integer range with one step increments.

Example

use blackjack::prelude::*;
 
let series: Series<i32> = Series::arange(0, 10);

pub fn astype<A>(&self) -> Result<Series<A>, &'static str>where
    A: BlackJackData + FromStr,

Convert the series into another DType (creates a new series)

Example

use blackjack::prelude::*;

let series: Series<i32> = Series::arange(0, 10);
assert_eq!(series[0].dtype(), DType::I32);
let new_series = series.astype::<f64>().unwrap();
assert_eq!(new_series[0].dtype(), DType::F64);

pub fn into_type<A>(self) -> Result<Series<A>, &'static str>where
    A: BlackJackData + FromStr,

Convert this series into another DType (consumes current series)

Example

use blackjack::prelude::*;

let series: Series<i32> = Series::arange(0, 10);
assert_eq!(series[0].dtype(), DType::I32);
let new_series = series.into_type::<f64>().unwrap();
assert_eq!(new_series[0].dtype(), DType::F64);

pub fn unique(&self) -> Series<T>where
    T: PartialOrd + Copy,

Get a series of the unique elements held in this series

Example

use blackjack::prelude::*;
 
let series: Series<i32> = Series::from_vec(vec![1, 2, 1, 0, 1, 0, 1, 1]);
let unique: Series<i32> = series.unique();
assert_eq!(unique, Series::from_vec(vec![0, 1, 2]));

pub fn from_vec(vec: Vec<T>) -> Self

Create a new Series struct from a vector, where T is supported by BlackJackData.

Example

use blackjack::prelude::*;
 
let series: Series<i32> = Series::from_vec(vec![1, 2, 3]);

pub fn into_vec(self) -> Vec<T>

Convert the series to a Vec
Type Annotations required Will coerce elements into the desired DType primitive, just as [SeriesTrait::astype()].

Example

use blackjack::prelude::*;
 
let series = Series::from_vec(vec![1_f64, 2_f64, 3_f64]);
 
assert_eq!(
    series.clone().into_vec(),
    vec![1_f64, 2_f64, 3_f64]
);

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

Set the name of a series

pub fn name(&self) -> Option<String>

Get the name of the series; Series may not be assigned a string, so an Option is returned.

Example

use blackjack::prelude::*;
 
let mut series = Series::from_vec(vec![1, 2, 3]);
series.set_name("my-series");
 
assert_eq!(series.name(), Some("my-series".to_string()));

pub fn mode(&self) -> Result<Self, &'static str>where
    T: BlackJackData + PartialOrd + Copy + ToPrimitive,

Finds the returns a Series containing the mode(s) of the current Series

pub fn var(&self) -> Result<f64, &'static str>where
    T: BlackJackData + ToPrimitive + Copy,

Calculate the variance of the series
NOTE that whatever type is determined is what the values are cast to during calculation of the variance.

ie. series.var::<i32>() will cast each element into i32 as input for calculating the variance, and yield a i32 value. If you want all values to be calculated as f64 then specify that in the type annotation.

pub fn std(&self) -> Result<f64, &'static str>where
    T: BlackJackData + ToPrimitive + Copy,

Calculate the standard deviation of the series

Example

use blackjack::prelude::*;
 
let series = Series::arange(0, 10).astype::<f32>().unwrap();
 
let std = series.std().unwrap(); // Ok(2.8722...)
assert!(std > 2.87);
assert!(std < 2.88);

pub fn sum(&self) -> Twhere
    T: Num + Copy + Sum,

Sum a given series, yielding the same type as the elements stored in the series.

pub fn mean<'a>(&'a self) -> Result<f64, &'static str>where
    T: ToPrimitive + Copy + Sum<&'a T> + Num + Sum,

Average / Mean of a given series - Requires specifying desired float return annotation

Example:

use blackjack::prelude::*;
 
let series = Series::arange(0, 5);
let mean = series.mean();
 
match mean {
    Ok(result) => {
        println!("Result is: {}", &result);
        assert_eq!(result, 2.0);
    },
    Err(err) => {
        panic!("Was unable to compute mean, error: {}", err);
    }
}

pub fn quantile(&self, quantile: f64) -> Result<f64, &'static str>where
    T: ToPrimitive + BlackJackData,

Calculate the quantile of the series

Example:

use blackjack::prelude::*;
 
let series = Series::arange(0, 100).astype::<f32>().unwrap();
let qtl = series.quantile(0.5).unwrap(); // `49.5_f32`
 
assert!(qtl < 49.51);
assert!(qtl > 49.49);

pub fn median<'a>(&'a self) -> Result<f64, &'static str>where
    T: ToPrimitive + Copy + PartialOrd,

Calculate the median of a series

pub fn min(&self) -> Result<T, &'static str>where
    T: Num + Clone + Ord + BlackJackData,

Find the minimum of the series. If several elements are equally minimum, the first element is returned. If it’s empty, an Error will be returned.

Example

use blackjack::prelude::*;
 
let series: Series<i32> = Series::arange(10, 100);
 
assert_eq!(series.min(), Ok(10));

pub fn max(&self) -> Result<T, &'static str>where
    T: Num + Clone + Ord,

Exibits the same behavior and usage of [SeriesTrait::min], only yielding the Result of a maximum.

pub fn len(&self) -> usize

Determine the length of the Series

pub fn is_empty(&self) -> bool

Determine if series is empty.

pub fn dtype(&self) -> DType

Get the dtype, returns None if series dtype is unknown. in such a case, calling .astype() to coerce all types to a single type is needed.

pub fn append<V: Into<T>>(&mut self, val: V)

Append a BlackJackData element to the Series

Example

use blackjack::prelude::*;
 
let mut series = Series::from_vec(vec![0, 1, 2]);
assert_eq!(series.len(), 3);
 
series.append(3);
assert_eq!(series.len(), 4);

pub fn into_raw(self) -> *mut Self

As boxed pointer, recoverable by Box::from_raw(ptr) or SeriesTrait::from_raw(*mut Self)

pub fn from_raw(ptr: *mut Self) -> Self

Create from raw pointer

pub fn groupby(&self, keys: Series<T>) -> SeriesGroupBy<T>where
    T: ToPrimitive,

Group by method for grouping elements in a Series by key.

Example

use blackjack::prelude::*;

let series = Series::from_vec(vec![1, 2, 3, 1, 2, 3]);
let keys   = Series::from_vec(vec![4, 5, 6, 4, 5, 6]);

let grouped: Series<i32> = series.groupby(keys).sum();
assert_eq!(grouped.len(), 3);

let mut vals = grouped.into_vec();
vals.sort();
assert_eq!(vals, vec![2, 4, 6]);

Trait Implementations

impl<T> Add<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series + scalar

type Output = Series<T>

The resulting type after applying the + operator.

fn add(self, scalar_val: T) -> Series<T>

Performs the + operation.

impl<T> AddAssign<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync + FromPrimitive + AddAssign<T>,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series += scalar

fn add_assign(&mut self, scalar_val: T)

Performs the += operation.

impl<T> Clone for Series<T>where
    T: BlackJackData + Clone,

fn clone(&self) -> Series<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Series<T>where
    T: BlackJackData + Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Series<T>where
    T: BlackJackData + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Series<T>where
    T: BlackJackData,
    String: From<T>,

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

Formats the value using the given formatter.

impl<T> Div<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series - scalar

type Output = Series<T>

The resulting type after applying the / operator.

fn div(self, scalar_val: T) -> Series<T>

Performs the / operation.

impl<T> DivAssign<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync + DivAssign<T>,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series += scalar

fn div_assign(&mut self, scalar_val: T)

Performs the /= operation.

impl<T> Index<usize> for Series<T>where
    T: BlackJackData,

type Output = T

The returned type after indexing.

fn index(&self, idx: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T: BlackJackData> IndexMut<usize> for Series<T>

fn index_mut(&mut self, idx: usize) -> &mut T

Performs the mutable indexing (container[index]) operation.

impl<T> Mul<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series * scalar

type Output = Series<T>

The resulting type after applying the * operator.

fn mul(self, scalar_val: T) -> Series<T>

Performs the * operation.

impl<T> MulAssign<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync + MulAssign<T>,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

fn mul_assign(&mut self, scalar_val: T)

Performs the *= operation.

impl<T> PartialEq<Series<T>> for Series<T>where
    T: BlackJackData + PartialEq,

fn eq(&self, other: &Series<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Series<T>where
    T: BlackJackData + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync + Sub,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series - scalar

type Output = Series<T>

The resulting type after applying the - operator.

fn sub(self, scalar_val: T) -> Series<T>

Performs the - operation.

impl<T> SubAssign<T> for Series<T>where
    T: Num + Copy + BlackJackData + Send + Sync + SubAssign<T>,
    Vec<T>: IntoParallelIterator<Item = T>,
    <Vec<T> as IntoParallelIterator>::Iter: IndexedParallelIterator,

Support series -= scalar

fn sub_assign(&mut self, scalar_val: T)

Performs the -= operation.

impl<T> StructuralPartialEq for Series<T>where
    T: BlackJackData,