Struct brassfibre::prelude::DataFrame
[−]
[src]
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
[src]
///////////////////////////////////////////////////////////////////////////// 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
[src]
impl<'a, I, C> DataFrame<'a, 'a, 'a, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash
[src]
impl<'a, I, C> DataFrame<'a, 'a, 'a, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash + ToString
[src]
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
[src]
type Kept = Series<'c, 'c, f64, 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
[src]
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
[src]
impl<'v, 'i, 'c, I, C> Description<'c> for DataFrame<'v, 'i, 'c, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash
[src]
impl<'v, 'i, 'c, I, C> Display for DataFrame<'v, 'i, 'c, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash + Debug
[src]
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
[src]
impl<'v, 'i, 'c, I, C> Append<'c> for DataFrame<'v, 'i, 'c, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash
[src]
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
[src]
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
[src]
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
[src]
fn clone(&self) -> DataFrame<'v, 'i, 'c, I, C>
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0
Performs copy-assignment from source
. Read more
impl<'v, 'i, 'c, I, C> RowIndex<'c> for DataFrame<'v, 'i, 'c, I, C> where I: Clone + Eq + Hash, C: Clone + Eq + Hash
[src]
///////////////////////////////////////////////////////////////////////////// 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
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
[src]
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
[src]
///////////////////////////////////////////////////////////////////////////// Eq /////////////////////////////////////////////////////////////////////////////
fn eq(&self, other: &Self) -> bool
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0
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
[src]
///////////////////////////////////////////////////////////////////////////// Iterator /////////////////////////////////////////////////////////////////////////////