Struct brassfibre::prelude::DataFrame

pub struct DataFrame<'v, 'i, 'c, I, C> where
    I: 'i + Clone + Hash,
    C: 'c + Clone + Hash,  {
    pub values: Vec<Cow<'v, Array>>,
    pub index: Cow<'i, Indexer<I>>,
    pub columns: Cow<'c, Indexer<C>>,
}

Fields

values: Vec<Cow<'v, Array>>

2-dimentional block contains multiple type. I: type of indexer C: type of columns

index: Cow<'i, Indexer<I>>

columns: Cow<'c, Indexer<C>>

Methods

impl<'v, 'i, 'c, I, C> DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Misc /////////////////////////////////////////////////////////////////////////////

fn from_vec<X, Y>(values: Vec<Array>, index: X, columns: Y) -> Self where
    X: Into<Indexer<I>>,
    Y: Into<Indexer<C>>, 

fn dtypes(&self) -> Vec<String>

fn is_numeric(&self) -> Vec<bool>

fn insert(&mut self, values: Array, name: C)

fn groupby<G>(&'i self, other: Vec<G>) -> GroupBy<DataFrame<I, C>, G> where
    G: Clone + Eq + Hash + Ord, 

impl<'v, 'i, 'c, I, C> DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Hash + Eq,
    C: Clone + Hash + Eq, 

fn iter(&self) -> Iter<Cow<Array>>

impl<'a, I, C> DataFrame<'a, 'a, 'a, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

fn read_csv<R: Read>(
    reader: Reader<R>
) -> Result<DataFrame<'a, 'a, 'a, usize, String>, Error>

impl<'a, I, C> DataFrame<'a, 'a, 'a, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash + ToString, 

fn write_csv<W: Write>(&self, writer: &mut Writer<W>) -> Result<(), Error>

Trait Implementations

impl<'v, 'i, 'c, I, C> BasicAggregation<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: 'c + Clone + Eq + Hash, 

type Kept = Series<'c, 'c, Scalar, C>

type Counted = Series<'c, 'c, usize, C>

fn sum(&'c self) -> Self::Kept

fn count(&'c self) -> Self::Counted

impl<'v, 'i, 'c, I, C> NumericAggregation<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: 'c + Clone + Eq + Hash, 

type Coerced = Series<'c, 'c, f64, C>

fn mean(&'c self) -> Self::Coerced

fn var(&'c self) -> Self::Coerced

fn unbiased_var(&'c self) -> Self::Coerced

fn std(&'c self) -> Self::Coerced

fn unbiased_std(&'c self) -> Self::Coerced

impl<'v, 'i, 'c, I, C> ComparisonAggregation<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: 'c + Clone + Eq + Hash, 

type Kept = Series<'c, 'c, Scalar, C>

fn min(&'c self) -> Self::Kept

fn max(&'c self) -> Self::Kept

impl<'v, 'i, 'c, I, C> Description<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

type Described = DataFrame<'v, 'c, 'c, &'c str, C>

fn describe(&'c self) -> Self::Described

impl<'v, 'i, 'c, I, C> Display for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash + Debug, 

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

Formats the value using the given formatter.

impl<'v, 'i, 'c, I, C> Debug for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash + ToString,
    C: Clone + Eq + Hash + ToString, 

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

Formats the value using the given formatter.

impl<'v, 'i, 'c, I, C> Append<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

fn append<'o>(&'c self, other: &'o Self) -> Self

impl<'v, 'i, 'c, I, C> Concatenation<'i> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

fn concat<'o>(&'i self, other: &'o Self) -> Self

impl<'v, 'i, 'c, I, C> Join for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

fn join_inner(&self, other: &Self) -> Self

impl<'v, 'i, 'c, I: Clone, C: Clone> Clone for DataFrame<'v, 'i, 'c, I, C> where
    I: 'i + Clone + Hash,
    C: 'c + Clone + Hash, 

fn clone(&self) -> DataFrame<'v, 'i, 'c, I, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'v, 'i, 'c, I, C> RowIndex<'c> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

///////////////////////////////////////////////////////////////////////////// Indexing /////////////////////////////////////////////////////////////////////////////

type Key = I

type Row = Array

fn len(&'c self) -> usize

fn loc(&'c self, label: &Self::Key) -> Self::Row

Get a single value corresponding to given label (slice by LOCation)

fn iloc(&'c self, locaiton: &usize) -> Self::Row

Get a single value corresponding to given index (slice by Index LOCation)

fn reindex<'l>(&'c self, labels: &'l [Self::Key]) -> Self

fn reindex_by_index<'l>(&'c self, locations: &'l [usize]) -> Self

fn blocs(&self, labels: &[bool]) -> Self

Slice using given Vec (slice by Bool LOCationS)

fn head(&'s self, n: usize) -> Self

fn tail(&'s self, n: usize) -> Self

fn locs<'l>(&'s self, labels: &'l [Self::Key]) -> Self

Slice using given labels (slice by LOCationS)

fn ilocs<'l>(&'s self, locations: &'l [usize]) -> Self

Slice using given indices (slice by Index LOCationS)

impl<'v, 'i, 'c, I, C> ColIndex<'i> for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Eq + Hash,
    C: Clone + Eq + Hash, 

type Key = C

type Column = Array

fn get(&'i self, label: &Self::Key) -> Self::Column

Get column using label

fn iget(&'i self, loc: &usize) -> Self::Column

Get column using given index

fn gets<'l>(&'i self, labels: &'l [Self::Key]) -> Self

Slice columns using labels

fn igets<'l>(&'i self, locations: &'l [usize]) -> Self

Slice columns given indices

impl<'v, 'i, 'c, I, C> PartialEq for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Hash + Eq,
    C: Clone + Hash + Eq, 

///////////////////////////////////////////////////////////////////////////// Eq /////////////////////////////////////////////////////////////////////////////

fn eq(&self, other: &Self) -> 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 !=.

impl<'v, 'i, 'c, I, C> IntoIterator for DataFrame<'v, 'i, 'c, I, C> where
    I: Clone + Hash + Eq,
    C: Clone + Hash + Eq, 

///////////////////////////////////////////////////////////////////////////// Iterator /////////////////////////////////////////////////////////////////////////////

type Item = Cow<'v, Array>

The type of the elements being iterated over.

type IntoIter = IntoIter<Cow<'v, Array>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.