Struct 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> Clone for DataFrame<T>

where T: UtahNum + Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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<T> Debug for DataFrame<T>

where T: UtahNum + Debug,

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

Formats the value using the given formatter.

impl<'a, T> Operations<'a, T> for DataFrame<T>

where T: 'a + UtahNum,

Available on non-crate feature specialization only.

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 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.

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

impl<T> PartialEq for DataFrame<T>

where T: UtahNum + PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> ReadCSV<T> for DataFrame<T>

where T: UtahNum + Decodable + FromStr + Debug,

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

impl<T> StructuralPartialEq for DataFrame<T>

where T: UtahNum,