Struct utah::dataframe::DataFrame

pub struct DataFrame<T> where
    T: UtahNum,  {
    pub columns: Vec<String>,
    pub data: Matrix<T>,
    pub index: Vec<String>,
}

A read-only dataframe.

Fields

columns: Vec<String>

data: Matrix<T>

index: Vec<String>

Trait Implementations

impl<T: Debug> Debug for DataFrame<T> where
    T: UtahNum, 

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

Formats the value using the given formatter.

impl<T: Clone> Clone for DataFrame<T> where
    T: UtahNum, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq> PartialEq for DataFrame<T> where
    T: UtahNum, 

fn eq(&self, __arg_0: &DataFrame<T>) -> bool

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

fn ne(&self, __arg_0: &DataFrame<T>) -> bool

This method tests for !=.

impl<T> ReadCSV<T> for DataFrame<T> where
    T: UtahNum + Decodable, 

fn read_csv(file: &'static str) -> Result<DataFrame<T>>

impl<'a, T> Constructor<'a, T> for DataFrame<T> where
    T: UtahNum + 'a, 

fn new<U: Clone>(data: Matrix<U>) -> DataFrame<T> where
    T: From<U>, 

Create a new dataframe. The only required argument is data to populate the dataframe. By default, the columns and index of the dataframe are ["1", "2", "3"..."N"], where N is the number of columns (or rows) in the data.

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let df : DataFrame<f64> = DataFrame::new(a);

When populating the dataframe with mixed-types, wrap the elements with InnerType enum:

use utah::prelude::*;
let a = arr2(&[[InnerType::Float(2.0), InnerType::Str("ak".into())],
               [InnerType::Int32(6), InnerType::Int64(10)]]);
let df : DataFrame<InnerType> = DataFrame::new(a);

fn from_array<U: Clone>(data: Row<U>, axis: UtahAxis) -> DataFrame<T> where
    T: From<U>, 

Generate a 1-dimensional DataFrame from an 1-D array of data. When populating the dataframe with mixed-types, wrap the elements with InnerType enum.

use utah::prelude::*;
let a = arr1(&[2.0, 7.0]);
let df : DataFrame<f64> = DataFrame::from_array(a, UtahAxis::Column);

fn columns<U: Clone>(self, columns: &'a [U]) -> Result<DataFrame<T>> where
    String: From<U>, 

Populate the dataframe with a set of columns. The column elements can be any of OuterType. Example:

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let df : Result<DataFrame<f64>> = DataFrame::new(a).columns(&["a", "b"]);
df.is_ok();

fn index<U: Clone>(self, index: &'a [U]) -> Result<DataFrame<T>> where
    String: From<U>, 

Populate the dataframe with an index. The index elements can be any of OuterType. Example:

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let df : Result<DataFrame<f64>> = DataFrame::new(a).index(&["1", "2"]);
df.is_ok();

You can also populate the dataframe with both column names and index names, like so:

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let df : Result<DataFrame<f64>> = DataFrame::new(a).index(&["1", "2"]).unwrap().columns(&["a", "b"]);
df.is_ok();

fn df_iter(&'a self, axis: UtahAxis) -> DataFrameIterator<'a, T>

Return a dataframe iterator over the specified UtahAxis.

The dataframe iterator yields a view of a row or column of the dataframe for eventual processing. Example:

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let df : DataFrame<f64> = DataFrame::new(a).index(&["1", "2"]).unwrap().columns(&["a", "b"]).unwrap();
let df_iter = df.df_iter(UtahAxis::Row);

fn df_iter_mut(&'a mut self, axis: UtahAxis) -> DataFrameMutIterator<'a, T>

Return a mutable dataframe iterator over the specified UtahAxis.

The mutable dataframe iterator yields a view of a row or column of the dataframe for eventual processing. Example:

use utah::prelude::*;
let a = arr2(&[[2.0, 7.0], [3.0, 4.0]]);
let mut df : DataFrame<f64> = DataFrame::new(a);
let df_iter_mut = df.df_iter_mut(UtahAxis::Column);

impl<'a, T> Operations<'a, T> for DataFrame<T> where
    T: 'a + UtahNum, 

fn shape(self) -> (usize, usize)

Get the dimensions of the dataframe.

fn select<U: ?Sized>(
    &'a self,
    names: &'a [&'a U],
    axis: UtahAxis
) -> SelectIter<'a, T> where
    String: From<&'a U>, 

Select rows or columns over the specified UtahAxis.

fn remove<U: ?Sized>(
    &'a self,
    names: &'a [&'a U],
    axis: UtahAxis
) -> RemoveIter<'a, T> where
    String: From<&'a U>, 

Remove rows or columns over the specified UtahAxis.

fn append<U: ?Sized>(
    &'a mut self,
    name: &'a U,
    data: ArrayView1<'a, T>,
    axis: UtahAxis
) -> AppendIter<'a, T> where
    String: From<&'a U>, 

Append a row or column along the specified UtahAxis.

fn inner_left_join(&'a self, other: &'a DataFrame<T>) -> InnerJoinIter<'a, T>

Perform an inner left join between two dataframes along the specified UtahAxis.

fn outer_left_join(&'a self, other: &'a DataFrame<T>) -> OuterJoinIter<'a, T>

Perform an outer left join between two dataframes along the specified UtahAxis.

fn inner_right_join(&'a self, other: &'a DataFrame<T>) -> InnerJoinIter<'a, T>

Perform an inner right join between two dataframes along the specified UtahAxis.

fn outer_right_join(&'a self, other: &'a DataFrame<T>) -> OuterJoinIter<'a, T>

Perform an outer right join between two dataframes along the specified UtahAxis.

fn concat(
    &'a self,
    other: &'a DataFrame<T>,
    axis: UtahAxis
) -> ConcatIter<'a, T>

fn sumdf(&'a mut self, axis: UtahAxis) -> SumIter<'a, T>

Sum along the specified UtahAxis.

fn mapdf<F>(&'a mut self, f: F, axis: UtahAxis) -> MapDFIter<'a, T, F> where
    F: Fn(T) -> T, 

Map a function along the specified UtahAxis.

fn mean(&'a mut self, axis: UtahAxis) -> MeanIter<'a, T>

Get the average of entries along the specified UtahAxis.

fn maxdf(&'a mut self, axis: UtahAxis) -> MaxIter<'a, T>

Get the maximum of entries along the specified UtahAxis.

fn mindf(&'a mut self, axis: UtahAxis) -> MinIter<'a, T>

Get the minimum of entries along the specified UtahAxis.

fn impute(
    &'a mut self,
    strategy: ImputeStrategy,
    axis: UtahAxis
) -> ImputeIter<'a, T>

Replace empty values with specified ImputeStrategy along the specified UtahAxis.